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 towards 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
- 25 lectures, 1600+ slides
- Include the last 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 software engineer
If you enjoy the course or you find it useful, please add a Star
![stars - Modern-CPP-Programming](https://img.shields.io/github/stars/federico-busato/Modern-CPP-Programming?style=social)
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 and Floating-point types and their arithmetic |
5 |
Basic Concepts III (html) |
Entities, Enumerators, Structures, Control flow statements |
6 |
Basic Concepts IV (html) |
Heap, Stack, Pointers, References, Const properties, Conversion operators |
7 |
Basic Concepts V (html) |
Functions, Lambda expressions, Preprocessing directives |
8 |
Object-Oriented Programming I (html) |
Class hierarchy, Constructor, Destructor, Class keywords |
9 |
Object Oriented Programming II (html) |
Polymorphism, Operators overloading |
10 |
Templates and Meta-programming I (html) |
Function template, Type traits, Compile-time utilities |
11 |
Templates and Meta-programming II (html) |
Class template, SFINAE |
12 |
Translation Units I (html) |
Linkage and One Definition Rule |
13 |
Translation Units II (html) |
Dealing with multiple translation units and files,#include , Modules |
14 |
Code Conventions (html) |
Project organization, Main code conventions |
15 |
Debugging and Testing (html) |
Execution/memory debugging, Sanitizers, Harding techniques, Unit test, Test-Driven Development |
16 |
Ecosystem (html) |
Cmake, Documenting, and Other Tools |
17 |
Utilities (html) |
Main std libraries |
18 |
Containers, Iterators, and Algorithms (html) |
Containers, Iterators, Algorithms, Ranges |
19 |
Advanced Topics I (html) |
Move semantics, Universal reference, Type deduction |
20 |
Advanced Topics II (html) |
Error handling, C++ idioms, Smart pointers |
21 |
Performance Optimizations I (html) |
Ahmdal Law, Performance bounds, Architecture concepts (ILP, SIMD, etc.), Memory hierarchy |
22 |
Performance Optimizations II (html) |
Arithmetic optimizations, Memory optimizations, etc. |
23 |
Performance Optimizations III (html) |
Compiler optimizations, Profiling, Benchmarking tools |
24 |
Software Design I (html) |
Basic Concepts, Principles, Use cases |
25 |
Software Design II (html) |
Design Patterns and Idioms |
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, Suffix and prefix, Non-standard arithmetic types,
void
type, nullptr
- Conversion Rules
auto
declaration
- C++ Operators: Operators precedence, Prefix/Postfix increment/decrement, Assignment, compound, and comma operators, Spaceship operator
<=>
, Safe comparison operators
4. Basic Concepts II - Integral and Floating-point Types
- Integral Data Types: Fixed width integers,
size_t
and ptrdiff_t
, Signed/Unsigned integer characteristics, Promotion, Truncation, Undefined behavior
- Floating-point Types and Arithmetic: 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
5. Basic Concepts III - Entities and Control Flow
- Entities
- Declaration and Definition
- Enumerators
struct
, Bitfield, union
[[deprecated]]
Attribute
- Control Flow:
if
statement, for
loop, Range-base for
loop, switch
, goto
, Avoid unused variable warning
6. Basic Concepts IV - Memory Concepts
- Heap and Stack: Stack memory,
new
, delete
, Non-allocating placement allocation, Non-throwing allocation, Memory leak
- Initialization: Variable initialization, Uniform initialization, Fixed-size array initialization, Structure initialization, Dynamic memory initialization
- Pointers and References: Pointer operations, Address-of operator
&
, Reference
- Constant and Literals,
const
, constexpr
, consteval
, constinit
, if constexpr
, std::is constant evaluated()
, if consteval
volatile
keyword
- Explicit Type Conversion:
static_cast
, const_cast
, reinterpret_cast
, Type punning
sizeof
Operator: overview, [[no_unique_address]]
7. Basic Concepts V - Functions and Preprocessing
- Functions: Pass by-value, Pass by-pointer, Pass by-reference, Function signature and overloading, Overloading and
=delete
, Default parameters, Attributes [[attributes]]
- Function Pointer and Function Objects
- Lambda Expressions: Capture list, Parameters, Composability,
constexpr/consteval
, template
, mutable
, [[nodiscard]]
, 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
8. 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, [[nodiscard]]
and classes
- Copy Constructor
- Class Destructor
- Defaulted Constructors, Destructor, and Operators (
= default
)
- Class Keywords:
this
, static
, const
, mutable
, using
, friend
, delete
9. Object-Oriented Programming II - Polymorphism and Operator Overloading
- 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
10. Templates and Meta-programming I - Function Templates and Compile-Time Utilities
- Function Template: Overview, Template parameters,Template instantiation, Template parameter - default value, Overloading, Specialization
- Template Variable
- Template Parameter Types: Generic Type Notes,
auto
Placeholder, Class template parameter type, Array and pointer types, Function type
- Compile-Time Utilities:
static_assert
, decltype
keyword, using
keyword
- Type Traits: Overview, Type traits library, Type manipulation
11. 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: 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
12. Translation Units I - Linkage and One Definition Rule
- Basic Concepts: Translation unit, Local and global scope, Linkage
- Storage Class and Duration: Storage duration, Storage class,
static
and extern
keywords, Internal/External linkage examples
- 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 inline
- ODR - Function Template: Cases,
extern
keyword
- ODR - Class Template: Cases,
extern
keyword
- ODR Undefined Behavior and Summary
13. Translation Units II - Include, Module, and Namespace
#include
Issues: Include guard, Forward declaration, Circular dependencies, Common linking errors
- C++20 Modules: Overview, Terminology, Visibility and reachability, Module unit types, Keywords, Global module fragment, Private module fragment, Header module unit, Module partitions
- Namespace: Namespace functions vs.
static
methods, Namespace alias, Anonymous namespace, inline
namespace, Attributes and namespace
- Compiling Multiple Translation Units: Fundamental compiler flags, Compile Methods, Deal with libraries, Build static/dynamic libraries, Find dynamic library dependencies, Analyze object/executable symbols
14. Code Conventions
- C++ Project Organization: Project directories, Project files, "Common" project organization notes, Alternative - “Canonical” project organization
- Coding Styles and Conventions
#include
- Macro and Preprocessing
- Namespace
- Variables and Arithmetic Types
- Functions
- Structs and Classes
- Control Flow
- Modern C++ Features
- Maintainability
- Naming
- Readability and Formatting
- Code Documentation
15. Debugging and Testing
- Debugging
- Assertion
- Execution debugging: Breakpoints, Watchpoints / Catchpoints, Control flow, Stack and Info, Print, Disassemble
- Memory Debugging:
valgrind
- Hardening Techniques: Stack usage, Standard library checks, Undefined behavior protections, Control flow protections
- Sanitizers: Address sanitizer, Leak sanitizer, Memory sanitizers, Undefined behavior sanitizer
- Debugging Summary
- Compiler Warnings
- Static Analysis
- Code Testing: Unit test, Test-Driven Development (TDD), Code coverage, Fuzz testing
- Code Quality:
clang-tidy
16. Ecosystem - Cmake and Other Tools
- CMake:
cmake
and ctest
- Code Documentation:
doxygen
- Code Statistics: Count lines of code, Cyclomatic complexity analyzer
- Other Tools: Code formatting -
clang-format
, Compiler Explorer
, Code transformation - CppInsights
, Code autocompletion - GitHub Co-Pilot/TabNine/Kite
, Local code search - ugrep
, ripgrep
, hypergrep
, Code search engine - searchcode/grep.app
, Code benchmarking - Quick-Bench
, Font for coding
17. Utilities
- I/O Stream: Manipulator,
ofstream/ifstream
- Strings:
std::string
, Conversion from/to numeric values, std::string_view
, std::format
, std::print
- View:
std::span
- Math Libraries
- Random Number: Basic concepts, C++
<random>
, Seed, PRNG period and quality, Distribution, Quasi-random
- Time Measuring: Wall-Clock time, User time, System time
- Std Class Templates:
std::pair
, std::tuple
, std::variant
, std::optional
, std::any
, std::stacktrace
- Filesystem Library: Query methods, Modify methods
18. Containers, Iterators, and Algorithms
- Containers and Iterators
- Sequence Containers:
std::array
, std::vector
, std::list
, std::deque
, std::forward_list
- Associative Containers:
std::set
, std::map
, std::multiset
- Container Adaptors:
std::stack
, std::queue
, std::priority_queue
- View:
std::span
- Implement a Custom Iterator: Semantic, Implement a simple Iterator
- Iterator Notes:
- Iterator Utility Methods:
std::advance
, std::next
, std::prev
, std::distance
, Container access methods, Iterator traits
- Algorithms Library:
std::find_if
, std::sort
, std::accumulate
, std::generate
, std::remove_if
- C++20 Ranges: Key concepts, Range view, Range adaptor, Range factory, Range algorithms, Range actions
19. Advanced Topics I
- Move Semantic:
lvalues
and rvalues
references, Move semantic, std::move
, Class declaration semantic
- Universal Reference and Perfect Forwarding: Universal reference, Reference collapsing rules, Perfect forwarding
- Value Categories
&
, &&
Ref-qualifiers and volatile
Overloading
- Copy Elision and RVO
- Type Deduction: Pass by-reference, Pass by-pointer, Pass by-value,
auto
deduction, auto(x)
: Decay-copy
const
Correctness
20. Advanced Topics II
- Undefined Behavior: Illegal behavior, Platform specific behavior, unspecified behavior, Detecting undefined behavior
- Error Handling: Recoverable error handing, Return code, C++ Exceptions, Defining custom exceptions,
noexcept
keyword, Memory allocation issues, Return code and exception summary, std::expected
, Alternative error handling approaches
- Smart pointers:
std::unique_ptr
, std::shared_ptr
, std::weak_ptr
- Concurrency: Thread methods, Mutex, Atomic, Task-based parallelism
21. Optimization I - Basic Concepts
- Introduction: Moore's Law, Moore's Law limitations, Reasons for optimizing
- Basic Concepts: Asymptotic complexity, Time-Memory trade-off, Developing cycle, Ahmdal's law, Throughput, Bandwidth, Latency, Performance bounds, Arithmetic intensity
- Basic Architecture Concepts: Instruction throughput, In-Order, and Out-of-Order Execution, Instruction pipelining, Instruction-level parallelism (ILP), Little’s law, Data-level parallelism (DLP) and SIMD, Thread-level parallelism (TLP), Single Instruction Multiple Threads (SIMT), RISC, CISC instruction sets
- Memory Hierarchy: Memory hierarchy concepts, Memory locality, Core-to-core latency and thread affinity, Memory ordering model
22. Optimization II - Code Optimization
- I/O Operations:
printf
, Memory mapped I/O, Speed up raw data loading
- Memory Optimizations: Heap memory, Stack memory, Cache utilization, Data alignment, Memory Prefetch
- Arithmetic Types: Data types, Arithmetic operations, Conversion, Floating-point, Compiler intrinsic functions, Value in a range, Lookup table
- Control Flow: Branch Hints -
[[likely]]
/ [[unlikely]]
, Signed/Unsigned integers, Loops, Loop hoisting, Loop unrolling, Assertions, Compiler hints [[assume]]
, Recursion
- Functions: Function call cost, Argument passing, Function inlining, Function attributes, Pointers aliasing
- Object-Oriented Programming
- Std Library and Other Language Aspects
23. Optimization III - Non-Coding Optimizations and Benchmarking
- Compiler Optimizations: About the compiler, Compiler optimization flags, Floating-point optimization flags, Linker optimization flags, Architecture flags, Help the compiler to produce better code, Profile guided optimization (PGO), Post-processing binary optimizer
- Compiler Transformation Techniques: Basic transformations, Loop unswitching, Loop fusion, Loop fission, Loop interchange, Loop tiling
- Libraries and Data Structures: External libraries
- Performance Benchmarking: What to test?, Workload/Dataset quality, Cache behavior, Stable CPU performance, Multi-threads considerations, Program memory layout, Measurement overhead, Compiler optimizations, Metric evaluation
- Profiling:
gprof
, uftrace
, callgrind
, cachegrind
, perf
Linux profiler
- Parallel Computing: Concurrency vs. parallelism, Performance scaling, Gustafson's Law, Parallel programming languages
24. Software Design I - Basic Concepts (DRAFT)
- Books and References
- Basic Concepts: Abstraction, interface, and module, Class Invariant
- Software Design Principles: Separation of concern, Low coupling, high cohesion, Encapsulation and information hiding, Design by contract, Problem decomposition, Code reuse
- Software Complexity: Software entropy, Technical debt
- The SOLID Design Principles
- Member Functions vs. Free Functions
- BLAS GEMM Case Study
- Owning Objects and Views
- Value vs. Reference Semantic
- Global Variables
25. Software Design II - Design Patterns and Idioms (DRAFT)
- C++ Idioms: Rule of Zero, Rule of Three, Rule of Five
- Design Pattern: Singleton, PIMPL, Curiously Recurring Template Pattern (CRTP), Template virtual functions
Roadmap
- Improve Software Design Chapters
- Build Aspects Chapter (e.g. reducing build time)
Reporting bugs 🐛 and contributing
If you find any typo, conceptual error, or section to improve, please report them by using the issue
panel.
Author
Federico Busato
, https://federico-busato.github.io/