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

CHAPTERS

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

1. Improve Software Design Chapters
2. 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/

• LinkedIn: www.linkedin.com/in/federico-busato/
• Twitter: twitter.com/fedebusato