Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Trace how assignment, arithmetic operators, and compound updates like `+=` change a value step by step. Notice common surprises such as integer division dropping the fractional part.

Use what you learned in the previous lesson to solve real-world problems.

Use `std::cout` or `printf` to inspect values while a program runs. Read printed output as evidence of what your variables actually contain.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Use `if`, `else`, comparison operators, and logical operators to choose between two paths. Reason through which block runs for a given set of values.

Use what you learned in the previous lesson to solve real-world problems.

Write a `for` loop when you know how many times work should repeat. Trace the initializer, condition, body, and update in the order the CPU executes them.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Write a `while` loop when repetition depends on a condition becoming false. Identify the update that must happen inside the loop so it eventually stops.

Use what you learned in the previous lesson to solve real-world problems.

Check loop bounds with zero-based indexes and the `i < n` pattern. Spot why `<= n` often reads or writes one element past the end.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Create a fixed-size C-style array and access elements with indexes starting at zero. Connect each index to one stored value and recognize what an out-of-range index means.

Use what you learned in the previous lesson to solve real-world problems.

Use `std::vector` for host-side arrays that know their own size and can grow. Practice `size()`, indexing, and `data()` so vector storage can still work with pointer-based APIs later.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Fill, scale, copy, or sum an array by visiting one element per loop iteration. Match each loop index to the input and output element it should touch.

Use what you learned in the previous lesson to solve real-world problems.

Define a function with parameters, call it with arguments, and use its return value. Separate the reusable calculation inside the function from the code that asks for the result.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Compare returning one result with changing a value through a reference or pointer parameter. Decide when a function should produce a new value and when it should update storage supplied by the caller.

Use what you learned in the previous lesson to solve real-world problems.

Write a function that receives `T* data` and a count, then loops over the elements safely. Treat the pointer as the start of the array and the length as the rule that keeps access in bounds.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Use `&` to get a variable’s memory address and `*` to read or write the value a pointer refers to. Trace the difference between the pointer variable and the data it points at.

Use what you learned in the previous lesson to solve real-world problems.

Relate `array[i]`, `*(array + i)`, and `p + i` to the same contiguous storage. Reason about how pointer arithmetic moves by elements, not raw byte counts in your source code.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Track when local variables, arrays, and pointed-to data stop being valid. Recognize dangling pointers, `nullptr`, and the risk of using an address after its storage is gone.

Use what you learned in the previous lesson to solve real-world problems.

Allocate an array whose size is known only at runtime, then release it correctly with the matching cleanup operation. Compare manual allocation with the safer default of using `std::vector` when possible.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Mark function inputs as `const` when they should not be changed. Use const-correct parameters to make read-only data clear and catch accidental writes at compile time.

Use what you learned in the previous lesson to solve real-world problems.

Compile a single source file with `g++` or `clang++`, choose a C++ standard flag, and run the produced executable. Connect the command you type to the source file and output program it creates.

Distinguish errors caused by bad syntax or types from linker errors caused by missing function definitions. Use the wording of the message to decide whether to fix code structure or missing build inputs.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Read an error message by file name, line number, error kind, and nearby code. Fix the first real error before chasing later messages that may only be side effects.

Use what you learned in the previous lesson to solve real-world problems.

Turn on warnings such as `-Wall` and `-Wextra` to catch risky code before it fails. Treat messages about uninitialized values, conversions, and signed/unsigned comparisons as useful debugging clues.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Recognize crashes, out-of-bounds access, and uninitialized reads as runtime problems even when compilation succeeds. Shrink the input and print key values to find the line where memory first goes wrong.

Use what you learned in the previous lesson to solve real-world problems.

Check what you understood with a short quiz.

Review this chapter with practice based on your mistakes.