Programming Fundamentals : A Modular Structured Approach using C++, 1st edition

Kenneth Leroy Busbee’s Programming Fundamentals introduces modular, structured problem solving through C++. This guide follows the source’s 24 instructional chapters, review section, and appendix, emphasizing planning, tracing, testing, and explaining code rather than copying solutions.

How to study this book

Write pseudocode and expected results before implementation. Compile small examples, read diagnostics, and test normal, boundary, and invalid inputs. Keep a trace table for unfamiliar control flow. The book uses an older compiler environment and warns of PDF conversion errors in C++ symbols, so inspect examples carefully.

Chapter-wise explanations and study tasks

1. Introduction to Programming

Programming begins with a problem and a development process, not simply typing code. Program layout and modularization provide structure, while the historical IDE example illustrates a toolchain. Distinguish source code, compilation, and execution.

Study task: Describe the stages from a simple requirement to a tested program and identify the artefact produced at each stage.

2. Program Planning and Design

Design, pseudocode, and test data make the intended logic explicit before syntax complicates the task. A useful plan states inputs, processing, outputs, and assumptions. Expected results provide an independent basis for checking implementation.

Study task: Write pseudocode and a test table for converting a quantity between two units.

3. Data and Operators

Types, names, constants, variables, assignment, arithmetic, and conversion determine how data are represented and changed. Assignment is an operation, not a mathematical claim of permanent equality. Trace values step by step.

Study task: Predict the values in a short arithmetic sequence and identify where a type conversion changes the result.

4. Often Used Data Types

Integers, floating-point values, and strings represent different kinds of data. Division and remainder require attention to operand types. Select a representation according to meaning rather than treating every numerical-looking input as interchangeable.

Study task: Compare integer and floating-point calculations and explain an application where each representation is appropriate.

5. Integrated Development Environment

An IDE combines editing and build-related activities, while input, output, and directives belong to the program and toolchain. Learn the workflow without assuming historical menu instructions match your environment.

Study task: Compile a small input–calculation–output program in your course environment and record a diagnostic you corrected.

6. Program Control Functions

Functions divide a problem into coordinated responsibilities. Pseudocode and structure charts reveal how tasks connect. Keep the purpose and interface of each function clear before choosing how to arrange its statements.

Study task: Draw a structure chart for a three-stage calculation and describe each function’s responsibility.

7. Specific Task Functions

Task-focused functions and local storage reduce unnecessary coupling. Headers help separate declarations from use. Compare the visibility and lifetime of data rather than assuming that globally accessible variables are always convenient.

Study task: Refactor a fictional calculation into focused functions and explain which data should remain local.

8. Standard Libraries

Library facilities provide reusable functionality under defined interfaces. Using a function requires understanding its inputs, output, and preconditions. A recognized library name does not remove the need to check types and results.

Study task: Choose a source library example and document its required header, arguments, return meaning, and one boundary case.

9. Characters, Sizeof, Typedef, and Sequence

The chapter joins several representation tools: character values, storage-size queries, aliases, and sequencing. These concepts answer different questions. Avoid assuming a type alias creates a new independent type or that every platform uses identical sizes.

Study task: Write a small observation table for character data and type sizes, distinguishing measured implementation results from general language concepts.

10. Structured Programming

Sequence, selection, and iteration organize control flow. Pseudocode and flowcharts offer alternative representations of the same logic. Use them to expose paths and termination conditions, not merely to decorate completed code.

Study task: Represent a simple algorithm in both pseudocode and a flowchart and check that all paths match.

11. Two-Way Selection

Boolean expressions and conditional branches determine which statements execute. Braces and comparison operators affect meaning. Test both sides of a condition and the boundary rather than only the expected case.

Study task: Create tests just below, at, and above a threshold and trace the selected branch.

12. Multiway Selection

Multiple alternatives require a deliberate ordering and coverage strategy. Conditions may overlap or leave cases unhandled. Compare the chapter’s selection approaches according to the shape of the decision.

Study task: Design a multi-category decision table and verify that every intended input has one appropriate outcome.

13. Test-After Loops

A test-after loop performs its body before checking continuation. That guarantees at least one pass, which may or may not match the requirement. Track the condition and state update together.

Study task: Trace a test-after loop and explain why it is suitable—or unsuitable—for an empty-input case.

14. Test-Before Loops

A test-before loop may execute zero times. Initialization, condition, body, and update must cooperate to make progress. A condition that is initially true does not establish eventual termination.

Study task: Construct a trace table including a zero-iteration case and a case that would reveal a missing update.

15. Counting Loops

Counting loops make repeated work and progression explicit. Boundaries determine how many iterations occur. Distinguish the number of elements from the largest valid index when a loop processes a collection.

Study task: Write a loop for a stated number of items and verify the first value, last value, and iteration count.

16. String Class and Unary Signs

Strings support textual data while unary positive and negative operate on values in expressions. Keep text handling separate from numerical conversion assumptions. Read operator meaning in its actual syntactic context.

Study task: Trace a short string-and-number example and explain each use of a sign or operator.

17. Conditional Operator and Recursion

A conditional expression produces a selected value, while recursion solves a problem through related function calls. A recursive design needs a base case and progress toward it. Concise syntax does not automatically make logic clearer.

Study task: Trace a small recursive example to its base case and compare a conditional expression with an equivalent explicit selection.

18. Introduction to Arrays

Arrays group indexed values under a fixed organization. Index, element, and size are different concepts. Correct traversal requires explicit bounds and an understanding of what each position represents.

Study task: Draw an indexed array and trace a sum calculation, checking the empty or minimum-size assumption.

19. File I/O and Array Functions

File operations connect external data with program state and array processing. Input success and data shape must be checked rather than presumed. Separate reading, processing, and reporting responsibilities.

Study task: Design a file-processing outline that handles an empty file and malformed input before analysing stored values.

20. More Array Functions

Additional array operations extend traversal and modular processing. A function should state how many elements are valid and what changes it makes. Test repeated values and boundary positions as well as ordinary data.

Study task: Specify and test an array operation with normal, repeated-value, and boundary cases.

21. More on Typedef

Aliases can make representations and interfaces easier to change consistently. They do not remove assumptions embedded in operations on the underlying type. Examine what changing an alias actually affects.

Study task: Review a small alias-based design and identify operations that would need reconsideration if its underlying representation changed.

22. Pointers

Addresses, references, pointer values, and indirection connect expressions with stored objects. Distinguish an address from the object’s value and consider whether the object is valid. Draw relationships before tracing mutations.

Study task: Create a memory diagram showing a variable, a pointer to it, and the effect of a valid indirect update.

23. More Arrays and Compiler Directives

Multidimensional arrays organize indexed data, while conditional compilation selects source before runtime. These are different mechanisms. Distinguish compile-time selection from a conditional statement executed by the program.

Study task: Trace a small two-dimensional traversal and explain how a conditional-compilation choice differs from a runtime branch.

24. OOP and HPC

The final instructional chapter introduces object-oriented and high-performance computing ideas rather than offering a full advanced course. Compare organizing responsibilities with improving execution performance. A faster implementation still needs correct behaviour.

Study task: Outline how data and operations could be grouped in an object and identify a separate performance question requiring measurement.

25. Review Materials

The review groups revisit foundations, modularity, structure, and later topics. Mixed practice tests method selection rather than recall of the immediately preceding example. Use mistakes to identify dependencies in your understanding.

Study task: Complete a mixed review without viewing solutions and classify errors by planning, representation, control flow, or implementation.

26. Appendix and Reference Material

Operator precedence, reserved words, character information, environment notes, and study guidance support practice. Reference tables help resolve a specific uncertainty but do not replace readable expressions or honest attribution.

Study task: Use the appendix to resolve an operator question and rewrite the expression with parentheses that make the intended grouping clear.

Applied assignment

Build a small modular program that reads synthetic records, validates input, stores values, calculates a summary, and writes a result. Submit pseudocode, function responsibilities, trace examples, a test table, and an explanation of one corrected defect.

Suggested reading plan

Study chapters 1–5 for foundations, 6–9 for modularity and representation, and 10–17 for control flow. Continue through 18–23 for collections, files, and memory concepts, then use 24 for orientation and 25–26 for cumulative review and reference.

Questions for reflection

• What independent expected result checks the program’s output?
• Which input exposes a boundary or termination error?
• Does the code’s structure make its assumptions and responsibilities clear?

Edition and source notes

Based on Busbee’s linked first-edition Connexions collection, listed as 2013 in the library, with 24 instructional chapters, review materials, and an appendix. Its Dev-C++ instructions and platform references are historical. The PDF explicitly warns that decrement and stream insertion/extraction symbols may convert incorrectly; confirm intended syntax rather than copying corrupted glyphs.

Consult the official source and full text.