Learn C++ from compilation to a tested application

Understand source files, compilation, linking, and execution, then run and modify a complete C++ console program without assumed experience.

Store meaningful values with deliberate types, initialization, const, and type inference while avoiding uninitialized data and misleading conversions.

Calculate with integer and floating-point values, understand precedence and division, and make conversions visible when they can change meaning.

Work with std::string, formatted output, token and line input, and stream-state validation without leaving unread data to break the next operation.

Translate rules into readable if statements, compound Boolean expressions, and switch branches while keeping boundary behavior explicit.

Choose for, while, and range-based loops from the stopping rule, then avoid off-by-one errors, accidental infinite loops, and invalid ranges.

Design focused functions with explicit inputs, outputs, const-correct parameters, and contracts that can be tested independently of console code.

Classify compile, link, runtime, logic, and undefined-behavior failures, then investigate them with warnings, sanitizers, a debugger, and small test cases.

Store sequences with std::array and std::vector, choose a container from size requirements, and access elements without confusing size with a valid index.

Express search, count, sort, transformation, and accumulation with iterator ranges and standard algorithms while keeping mutation and complexity visible.

Distinguish values, references, and pointers, express optional non-owning access, and apply const correctly without creating dangling lifetimes.

Tie resource lifetime to object lifetime, prefer automatic storage and value members, and use unique_ptr or shared_ptr only when ownership requires them.

Group related state and behavior into domain types, understand value semantics, and choose struct or class from interface intent rather than habit.

Establish valid objects with constructors and initializer lists, protect invariants behind focused methods, and avoid partially initialized state.

Assemble behavior through composition, use virtual interfaces only at real variation points, and prevent slicing and ownership mistakes.

Write reusable type-safe functions and classes, understand instantiation and constraints, and recognize when ordinary overloads are clearer.

Separate expected alternatives from exceptional failures using return values, optional results, exceptions, and RAII-based cleanup.

Read and write files with RAII stream objects, validate open and parse states, choose a data format deliberately, and avoid fragile machine-specific paths.

Organize headers and source files, define build targets with CMake, enable compiler diagnostics, and test domain rules independently of the console.

Plan, implement, test, and document a multi-file command-line task tracker using modern C++ ownership, containers, algorithms, files, and CMake.