Modern C++ Programming
C++03 / C++11 / C++14 / C++17 / C++20 / C++23 / C++26
This open-access course is directed at those who are already familiar with C and object-oriented programming aiming for a proficiency level of C++ programming. The course covers the basics of C++ programming and moves on to advanced C++ semantics and concepts.
Key features:
- Free and frequently updated
- 29 lectures, 2000+ slides
- Includes the latest language standard concepts and features
- Practical teaching: non-verbose, short structured descriptions associated with code
- Minimal code examples for showing just a specific feature or issue without digressing
- Complementary language aspects: tools, coding conventions, project organization, and code optimization
- Experience-based: many aspects, examples, and problems come from real-world cases faced during my work as a software engineer
If you enjoy the course or you find it useful, please add a Star
Roadmap:
- Move from Latex to Typst.
- Fully-open source the material and allow direct contribution.
Table of Contents
CHAPTERS
| # |
TITLE |
MAIN FOCUS |
| 1 |
Introduction (html) |
History of C/C++, Areas of applications, Course introduction |
| 2 |
Preparation (html) |
Books, How to compile, Hello world |
| 3 |
Basic Concepts I (html) |
Type System, Fundamental types, and Operators |
| 4 |
Basic Concepts II (html) |
Integral types and arithmetic |
| 5 |
Basic Concepts III (html) |
Floating-point types and arithmetic |
| 6 |
Basic Concepts IV (html) |
Entities, Enumerators, Structures, Control flow statements |
| 7 |
Basic Concepts V (html) |
Heap, Stack, Pointers, References, Const properties, Conversion operators |
| 8 |
Basic Concepts VI (html) |
Functions, Lambda expressions, Preprocessing directives |
| 9 |
Object-Oriented Programming I (html) |
Class hierarchy, Constructor, Destructor, Class keywords |
| 10 |
Object Oriented Programming II (html) |
Polymorphism, Operators overloading |
| 11 |
Templates and Meta-programming I (html) |
Function template, Type traits, Compile-time utilities |
| 12 |
Templates and Meta-programming II (html) |
Class template, SFINAE |
| 13 |
Translation Units I (html) |
Linkage and One Definition Rule |
| 14 |
Translation Units II (html) |
Dealing with multiple translation units and files,#include, Modules |
| 15 |
Code Conventions I (html) |
Project organization, Code conventions intro, Entities conventions |
| 16 |
Code Conventions II (html) |
Template, Namespace, Modern C++, Maintainability, Naming, and Formatting conventions |
| 17 |
Debugging and Testing (html) |
Execution/memory debugging, Sanitizers, Hardening techniques, Unit tests, Test-Driven Development |
| 18 |
Ecosystem (html) |
Cmake, Documenting, and Other Tools |
| 19 |
Utilities (html) |
Main std libraries |
| 20 |
Containers, Iterators, and Algorithms (html) |
Containers, Iterators, Algorithms, Ranges |
| 21 |
Advanced Topics I (html) |
Move semantics, Universal reference, Type deduction |
| 22 |
Advanced Topics II (html) |
Error handling, C++ idioms, Smart pointers |
| 23 |
Performance Optimizations I (html) |
Amdahl's Law, Performance bounds, Architecture concepts (ILP, SIMD, etc.), Memory hierarchy |
| 24 |
Performance Optimizations II (html) |
Arithmetic optimizations, Memory optimizations, etc. |
| 25 |
Performance Optimizations III (html) |
Compiler optimizations, Profiling, Benchmarking tools |
| 26 |
Software Design I (html) |
Basic Concepts, Principles, Use cases |
| 27 |
Software Design II (html) |
Design Patterns and Idioms |
| 28 |
Binary Size (html) |
Binary size aspects |
| 29 |
Build Time (html) |
Build time aspects |
ALL-IN-ONE BOOK: modern-cpp.pdf (could be a few commits behind), html
TOPICS IN DETAILS
1. Introduction
- A Little History of C/C++ Programming Languages.
- Areas of Application and Popularity.
- C++ Philosophy.
- C++ Weakness: C++ alternatives, Why switching to a new language is hard?.
- The Course.
2. Preparation
- Books and References.
- Slide Legend.
- What Editor/ IDE/Compiler Should I Use?.
- How to compile?.
- Hello World: I/O Stream.
3. Basic Concepts I - Type System, Fundamental Types, and Operators
- The C++ Type System: Type categories, Type properties.
- C++ Fundamental Types Overview: Arithmetic types, Non-standard arithmetic types,
void type, nullptr.
auto Keyword.- C++ Operators: Operators precedence, Prefix/Postfix increment/decrement semantic, Assignment, compound, and comma operators, Spaceship operator
<=>.
4. Basic Concepts II - Integral Types
- Integral Data Types: Suffix and Prefix, Fixed width integers,
size_t, ptrdiff_t, uintptr_t.
- Arithmetic Operation Semantics: Saturation Arithmetic.
- Integer Undefined behavior: Signed overflow, Other cases.
- Integer Conversion Rules: Same size conversion, Integer conversion rule, Arithmetic operation promotion rules, Safe comparison functions, Arithmetic operation special cases.
5. Basic Concepts III - Floating-point Types
- Floating-point Types: Suffix, IEEE Floating-point standard and other representations, Normal/Denormal values, Infinity, Not a Number (
NaN), Machine Epsilon, Units at the Last Place (ULP), Cheatsheet, Limits and useful functions, Arithmetic properties, Special values behavior, Undefined behavior, Detect floating-point errors.
- Floating-point Issues: Catastrophic cancellation, Floating-point comparison.
6. Basic Concepts IV - Entities and Control Flow
- Entities.
- Declaration and Definition.
- Enumerators.
struct, Bitfield, union: struct, Anonymous and unnamed struct, Bitfield, union.- Control Flow:
if statement, for and while loops, Range-based for loop, switch, Initializing statement, goto, Avoid unused variable warning.
- Namespace: Explicit global namespace, namespace alias,
using-declaration, using namespace-directive, inline namespace.
- Attributes:
[[nodiscard]], [[indeterminate]], [[maybe_unused]], [[deprecated]], [[noreturn]].
7. Basic Concepts V - Memory Concepts
- Pointers: Pointer operations, Address-of operator
&, struct member access, void pointer, Pointer conversion, Pointer arithmetic, Wild and dangling pointers.
- Fixed-size Array.
- References.
- Heap and Stack: Stack memory,
new, delete, Non-allocating placement allocation, Non-throwing allocation, Memory leak.
- Initialization: Variable initialization, Uniform initialization, Array initialization, Structure initialization, Structure binding, Dynamic memory initialization.
Const and Constant Expressions: Constants and literals, const, constexpr, constexpr Variables, constexpr Functions, constexpr objects, consteval, constinit.- Conditional Constant Expressions:
if constexpr, std::is constant evaluated(), if consteval.volatile Keyword.- Explicit Type Conversion:
static_cast, const_cast, reinterpret_cast, Type punning, std::bit_cast, Uniform initialization conversion, gls::narrow_cast.
sizeof and alignof Operators: sizeof, alignof, sizeof/alignof operator applied to struct, [[no_unique_address]].
8. Basic Concepts VI - Functions and Preprocessing
- Functions: Pass by-value, Pass by-pointer, Pass by-reference, Function signature and overloading, Overloading and
=delete, Default parameters.
- Function Pointer and Function Objects.
- Lambda Expressions: Capture list, Lambda expression and function relation, Parameter notes, Composability, Recursion,
constexpr/consteval, template, mutable, Capture list and classes.
- Preprocessing: Preprocessors, Common errors, Source location macros, Conditional compiling macros, Stringizing operator (
#), #error and #warning, #pragma, Token-pasting operator ##, Variadic macro.
9. Object-Oriented Programming I - Class Concepts
- C++ Classes: RAII idiom.
- Class Hierarchy.
- Access specifiers: Inheritance access specifiers, When use
public/protected/private for data members?.
- Class Constructor: Default constructor, Class initialization, Uniform initialization for objects, Delegate constructor,
explicit keyword.
- Copy Constructor.
- Class Destructor.
- Defaulted Constructors, Destructor, and Operators (
= default).
- Class Keywords:
this, static, const, mutable, using, friend, delete.
10. Object-Oriented Programming II - Polymorphism and Operator Overloading
- Polymorphism: C++ mechanisms for polymorphism,
virtual methods, Virtual table, override keyword, final keyword, Common errors, Pure virtual method, Abstract class and interface.
- Inheritance Casting and Run-time Type Identification.
- Operator Overloading: Overview, Comparison operator
<, Spaceship operator <=>, Subscript operator [], Multidimensional subscript operator [], Function call operator (), static operator [] and operator (), Conversion operator T(), Return type overloading resolution, Increment and decrement operators ++/--, Assignment operator =, Stream operator <<, Operator notes.
- C++ Object Layout: Aggregate, Trivial class, Standard-layout class, Plain old data (POD), Hierarchy.
11. Templates and Meta-programming I - Function Templates and Compile-Time Utilities
- Function Template: Overview, Template instantiation, Template parameters, Template parameter - default value, Overloading, Specialization.
- Template Variable.
- Template Parameter Types: Generic type notes,
auto placeholder, Function type.
- Compile-Time Utilities:
static_assert, using keyword, decltype keyword.
- Type Traits: Overview, Type traits library, Type manipulation.
12. Templates and Meta-programming II - Class Templates and SFINAE
- Class Template: Class specialization, Class template constructor.
- Constructor template automatic deduction (CTAD).
- Class Template - Advanced Concepts: Class + Function - specialization, Dependent names -
typename and template keywords, Class template hierarchy and using, friend keyword, Template template arguments.
- Template Meta-Programming.
- SFINAE: Substitution Failure Is Not An Error: Function SFINAE, Class SFINAE.
- Variadic Template: Homogeneous variadic parameters, Folding expression, Variadic class template.
- C++20 Concepts: Overview,
concept keyword, requires clause, requires expression, requires expression + clause, requires clause + expression, requires and constexpr, Nested requires.
- Template Debugging.
13. Translation Units I - Linkage and One Definition Rule
- Basic Concepts: Translation unit, Local and global scope, Linkage, Visibility.
- Storage Class and Duration: Storage duration, Storage class,
static keyword, Anonymous namespace, extern keyword.
- Linkage of
const and constexpr: Static initialization order fiasco.
- Linkage Summary.
- Dealing with Multiple Translation Units: Class in multiple translation units.
- One Definition Rule (ODR): Global variable issues, ODR - Point 3,
inline functions/variables, constexpr and `inlin
A free, open-access Modern C++ Programming course by Federico Busato covering standards from C++03 to C++26 — from language basics to advanced features, tools and optimization.