Outline updated November 2026
C++ and Object-Oriented Programming
Class Duration
35 hours of live training delivered over 5 days.
Student Prerequisites
- Professional programming experience in at least one language (C, C#, Java, Python, JavaScript, or equivalent)
- Familiarity with basic data structures and functions
- No prior C++ or formal object-oriented design experience required
Target Audience
Professional developers who need to become productive in C++, coming from C, a managed language such as C# or Java, or a scripting language. It fits teams inheriting C++ code, building performance-critical components, or integrating with native libraries. Developers already comfortable in C++ who want to modernize their habits should consider Effective Modern C++ instead.
Description
This hands-on course teaches modern C++ from the ground up, through the newest standard. Object-oriented design is the organizing thread, taught the way C++ is written today: value semantics and RAII first, inheritance where it fits. Students move from the language core and memory model through class design, polymorphism, templates, concepts, and the standard library. The course ends with testing and tooling. Students use AI coding assistants to explain unfamiliar code, generate tests, and propose refactorings.
Learning Outcomes
- Explain C++'s compilation model, memory model, and value semantics.
- Write idiomatic C++ with references, smart pointers, and RAII.
- Design classes with correct construction, destruction, copying, and moving.
- Apply inheritance and polymorphism, and know when composition fits better.
- Write generic code with templates and constrain it with concepts.
- Use standard library containers, algorithms, and ranges.
- Handle errors with exceptions, std::optional, and std::expected.
- Set up CMake, a package manager, sanitizers, and a test framework.
- Use AI coding assistants to explain C++ code and propose refactorings for review.
Training Materials
Comprehensive courseware is distributed online at the start of class.
Software Requirements
Visual Studio 2026 (Windows) or VS Code with a current GCC or Clang toolchain (any platform), plus CMake and Git. Portions of the course covering C++26-specific features use GCC or Clang where MSVC support lags. WG21 finished technical work on C++26 in March 2026, but the October 2026 ISO ballot on the draft did not pass, so publication is pending and C++26 features may still change. Coverage of individual C++26 features follows the standard's status and compiler support at delivery time. Access to an agentic AI coding assistant is required; a free tier is sufficient.
Training Topics
C++ Foundations
- Headers, modules, and translation units
- Visual Studio, GCC, Clang, and CMake
- Types, variables, and initialization
- Value semantics vs. reference semantics
- AI coding assistants for C++
Language Core
- Functions, overloading, and default arguments
- References and const correctness
- Namespaces and code organization
- Enumerations and type-safe alternatives to macros
- Error handling fundamentals
Memory and Resource Management
- Stack, heap, and object lifetime
- Pointers, references, and ownership
- RAII and scope-bound resources
- unique_ptr, shared_ptr, and weak_ptr
- Avoiding leaks, dangling pointers, and double frees
Classes and Encapsulation
- Class invariants and interfaces
- Constructors, destructors, and member initialization
- Copy and move semantics
- The rule of zero and the rule of five
- Operator overloading done tastefully
- Static members and friend functions
Inheritance and Polymorphism
- Base classes and virtual functions
- Abstract classes and interface design
- Overriding, final, and virtual destructors
- Object slicing and how to prevent it
- The costs of virtual dispatch
Composition and Object-Oriented Design
- Composition over inheritance
- SOLID principles in C++ terms
- Dependency injection without a framework
- Interfaces as seams for testing
- Common design patterns in modern C++
Templates and Generic Programming
- Function and class templates
- Template argument deduction and CTAD
- Concepts and constrained templates
- Generic vs. OO polymorphism
The Standard Library
- vector, map, and unordered_map
- Iterators and the algorithms library
- Ranges and views
- Strings, string_view, and text handling
- optional, variant, and expected
Error Handling and Contracts
- Exception safety guarantees
- noexcept and its implications
- std::optional and std::expected as alternatives
- Contracts with pre, post, and contract_assert
- Defensive coding vs. design by contract
Testing and Professional Tooling
- Unit testing with GoogleTest or Catch2
- CMake project structure and presets
- Dependency management with vcpkg or Conan
- Address, UB, and thread sanitizers
- Static analysis with clang-tidy
Object-Oriented Design in Practice
- Designing class hierarchies for real domains
- Refactoring toward better OO structure
- API design and header hygiene
- Reviewing AI-generated C++ for correctness and style