C++ CPE study plan

Set up a compiler toolchain (g++ or clang++) and compile, run, and debug a multi-file program from the command line without an IDE

Write and explain programs that declare, initialize, and convert between fundamental types, and predict integer overflow and truncation results before running them

Use std::cin and std::cout to read and format typed input, including detecting and recovering from failed extraction

Trace the flow of if/else, switch, and loop constructs by hand for given inputs, then verify with the debugger

Write functions with default arguments, overloading, and pass-by-reference versus pass-by-value, and justify each choice in a comment

Implement recursive functions and identify base cases and stack depth for each

Use arrays and std::string to process input, including bounds-safe iteration

Organize declarations into headers with include guards and compile a two-file program

Define structs and classes with constructors, member initializer lists, and const member functions

Apply encapsulation by making data private and exposing behavior through public methods

Implement operator overloading for comparison and stream output on your own type

Explain the difference between a class and a struct in C++ and when each is idiomatic

Use pointers and references correctly, including pointer arithmetic over arrays and null checks

Manage heap memory with new and delete, and identify leaks and double deletes in deliberately broken code

Convert between C-style arrays, pointers, and std::vector for the same algorithm

Read and explain compiler warnings and sanitizer output for memory errors

Implement and reason about dynamic allocation inside a class, including destructors and copy operations

Apply the rule of three and explain why copy construction and copy assignment must both be handled

Use std::vector and std::map to replace hand-written dynamic arrays and lookup loops

Write iterator-based loops and explain iterator invalidation for at least vector and map

Derive classes, override virtual functions, and demonstrate runtime polymorphism through a base-class pointer

Distinguish virtual from non-virtual destructors and show the failure mode of the wrong choice

Use abstract classes with pure virtual functions to define an interface

Explain object slicing and demonstrate it with a concrete example

Use templates to write a function template and a class template, and explain instantiation

Apply the standard library algorithms and lambdas to filter, transform, and accumulate a container

Use smart pointers (unique_ptr and shared_ptr) and justify ownership choices

Handle exceptions with try, catch, and custom exception types, and write exception-safe cleanup

Re-solve missed or shaky exercises from weeks 1 through 7 without notes, then compare against your earlier solutions

Write two timed practice programs of roughly 45 minutes each that combine classes, containers, and polymorphism

Produce a personal error sheet listing your five most frequent mistakes with the corrected pattern for each

Verify that every program in your folder compiles with warnings enabled and passes a sanitizer run