24. Further study checklist

Turn reading into a learning routine

You do not need to understand every C feature at once. Learn a small idea, try it in a program, and return to it later when a project gives it a purpose. Repetition with working examples is more effective than memorizing a long list of rules.

1. Read one topic and restate its main idea in your own words.
2. Type and run a small example; change one thing and predict what will happen.
3. Use the idea in a project, then revisit the chapter to fill gaps or check details.

Use the checklist below to identify what you can already do and what deserves another practice session. Progress means being able to explain and apply an idea, not just recognize its name.

You are ready to move beyond this guide when you can:

• Compile a multi-file program and explain the compiler/linker errors you
  encounter.
• Use types, conditions, loops, functions, arrays, and strings confidently.
• Explain the difference between an array, a pointer, and a C string.
• Pass pointers safely and check array bounds yourself.
• Allocate, resize, and free dynamic memory without leaks or invalid access.
• Design structures and split a program into modules with headers.
• Read and write files while checking errors.
• Use a debugger and at least one sanitizer.
• Explain undefined behavior and identify common causes.
• Write tests for boundary cases and failure paths.
• Read documentation for a standard-library function or compiler option.
• Build a small data structure and state its complexity and ownership rules.

Checkpoint: Pick three items from this checklist that still feel difficult.
For each, write a small program, test a normal case and a boundary case, and
explain what the compiler and runtime are doing.

A suggested study rhythm

For each chapter, use four passes:

1. Read: understand the terms and the example's purpose.
2. Trace: write down what each variable contains as the program runs.
3. Rebuild: close the guide and recreate the example from memory, then
   compare and correct it.
4. Extend: change one requirement and update the code and tests.

If you are stuck, reduce the task until you can explain each step. Compile
often. A small error found immediately is easier to understand than many
errors discovered after writing a large program. Revisit earlier topics when
needed; pointers, arrays, and strings become clearer through repeated use.

int main(void)
{
    int value = 3;
    int total = 0;

    for (int step = 0; step < 3; ++step) {
        total += value;
        ++value;
    }
     // Trace: total becomes 3, then 7, then 12. 
    return total == 12 ? 0 : 1;
}

To practice tracing, write down step, value, and total before and after
each loop iteration, then run the program to check your prediction.

A compact glossary

• Argument: a value supplied to a function call.
• Parameter: a named input in a function declaration or definition.
• Declaration: tells the compiler about a name and its type.
• Definition: creates an object or supplies a function body.
• Scope: the region where a name can be used.
• Lifetime: the period during which an object exists.
• Pointer: an object that stores a reference to another object's address.
• Invariant: a condition that must remain true for a data structure.
• Precondition: what must be true before an operation is called.
• Postcondition: what the operation promises after it completes.
• Undefined behavior: an operation for which the C standard makes no
  requirements; do not rely on its observed result.

int add(int left, int right);         // declaration 
int add(int left, int right)          // definition 
{
    return left + right;
}

int main(void)
{
    int answer = add(2, 3);           // Call with two arguments. 
    return answer == 5 ? 0 : 1;
}

left and right are parameters; answer stores the returned value. The
declaration tells the compiler the function's interface, and the definition
provides its implementation.

The goal is not to memorize every library function or every line of the
standard. The goal is to reason about types, bounds, lifetimes, ownership,
input, and failure; to use documentation; and to build programs whose
behavior you can explain and test.

After that, choose a direction: embedded C, operating-system programming,
networking, compilers, graphics, scientific computing, or another area. Each
has its own platform APIs and deeper topics; the C fundamentals in this guide
will help you approach them safely.