Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/federico-busato/modern-cpp-programming

Modern C++ Programming Course (C++03/11/14/17/20/23/26)
https://github.com/federico-busato/modern-cpp-programming

c-plus-plus code-quality compilers course courses cpp cpp-programming cpp03 cpp11 cpp14 cpp17 cpp20 cpp23 cpp26 debugging optimization programming template

Last synced: 7 days ago
JSON representation

Modern C++ Programming Course (C++03/11/14/17/20/23/26)

Awesome Lists containing this project

README 

        
# 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)](https://github.com/federico-busato/Modern-CPP-Programming)



## CHAPTERS



| #      | TITLE                                                                                                                                                                                  | MAIN FOCUS                                                                                        |

| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------|

| **1**  | [**Introduction**](01.Introduction.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/01.Introduction.html))                                                  | History of C/C++, Areas of applications, Course introduction                                      |

| **2**  | [**Preparation**](02.Preparation.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/02.Preparation.html))                                                     | Books, How to compile, Hello world                                                                |

| **3**  | [**Basic Concepts I**](03.Basic_Concepts_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/03.Basic_Concepts_I.html))                                      | Type System, Fundamental types, and Operators                                                     |

| **4**  | [**Basic Concepts II**](04.Basic_Concepts_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/04.Basic_Concepts_II.html))                                   | Integral and Floating-point types and their arithmetic                                            |

| **5**  | [**Basic Concepts III**](05.Basic_Concepts_III.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/05.Basic_Concepts_III.html))                                | Entities, Enumerators, Structures, Control flow statements                                        |

| **6**  | [**Basic Concepts IV**](06.Basic_Concepts_IV.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/06.Basic_Concepts_IV.html))                                   | Heap, Stack, Pointers, References, Const properties, Conversion operators                         |

| **7**  | [**Basic Concepts V**](07.Basic_Concepts_V.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/07.Basic_Concepts_V.html))                                      | Functions, Lambda expressions, Preprocessing directives                                           |

| **8**  | [**Object-Oriented Programming I**](08.Object_Oriented_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Object_Oriented_I.html))                       | Class hierarchy, Constructor, Destructor, Class keywords                                          |

| **9**  | [**Object Oriented Programming II**](09.Object_Oriented_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_II.html))                    | Polymorphism, Operators overloading                                                               |

| **10** | [**Templates and Meta-programming I**](10.Templates_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Templates_I.html))                                | Function template, Type traits, Compile-time utilities                                            |

| **11** | [**Templates and Meta-programming II**](11.Templates_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/11.Templates_II.html))                             | Class template, SFINAE                                                                            |

| **12** | [**Translation Units I**](12.Translation_Units_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Translation_Units_I.html))                             | Linkage and One Definition Rule                                                                   |

| **13** | [**Translation Units II**](13.Translation_Units_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/13.Translation_Units_II.html))                          | Dealing with multiple translation units and files,`#include`, Modules                             |

| **14** | [**Code Conventions**](14.Code_Convention.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Code_Convention.html))                                        | Project organization, Main code conventions                                                       |

| **15** | [**Debugging and Testing**](15.Debugging.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/15.Debugging.html))                                               | Execution/memory debugging, Sanitizers, Harding techniques, Unit test, Test-Driven Development    |

| **16** | [**Ecosystem**](16.Ecosystem.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/16.Ecosystem.html))                                                           | Cmake, Documenting, and Other Tools                                                               |

| **17** | [**Utilities**](17.Utilities.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Utilities.html))                                                           | Main `std` libraries                                                                              |

| **18** | [**Containers, Iterators, and Algorithms**](18.Iterators_Containers_Alg.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/18.Iterators_Containers_Alg.html)) | Containers, Iterators, Algorithms, Ranges                                                         |

| **19** | [**Advanced Topics I**](19.Advanced_Topics_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Advanced_Topics_I.html))                                   | Move semantics, Universal reference, Type deduction                                               |

| **20** | [**Advanced Topics II**](20.Advanced_Topics_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Advanced_Topics_II.html))                                | Error handling, C++ idioms, Smart pointers                                                        |

| **21** | [**Performance Optimizations I**](21.Optimization_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Optimization_I.html))                               | Ahmdal Law, Performance bounds, Architecture concepts (ILP, SIMD, etc.), Memory hierarchy         |

| **22** | [**Performance Optimizations II**](22.Optimization_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Optimization_II.html))                            | Arithmetic optimizations, Memory optimizations, etc.                                              |

| **23** | [**Performance Optimizations III**](23.Optimization_III.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_III.html))                         | Compiler optimizations, Profiling, Benchmarking tools                                             |

| **24** | [**Software Design I**](24.Software_Design_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/24.Software_Design_I.html))                                   | Basic Concepts, Principles, Use cases                                                             |

| **25** | [**Software Design II**](25.Software_Design_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Software_Design_II.html))                                | Design Patterns and Idioms                                                                        |



***ALL-IN-ONE BOOK***: [**modern-cpp.pdf**](modern-cpp.pdf) (could be a few commits behind), [html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html)



## TOPICS IN DETAILS



**[1. Introduction](01.Introduction.pdf)**



* **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](02.Preparation.pdf)**



- **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](03.Basic_Concepts_I.pdf)**



* **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](04.Basic_Concepts_II.pdf)**



* **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](05.Basic_Concepts_III.pdf)**



* **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](06.Basic_Concepts_IV.pdf)**



* **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](07.Basic_Concepts_V.pdf)**



* **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](08.Object_Oriented_I.pdf)**



* **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](09.Object_Oriented_II.pdf)**



* **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](10.Templates_I.pdf)**



* **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](11.Templates_II.pdf)**



* **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](12.Translation_Units_I.pdf)**



* **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](13.Translation_Units_II.pdf)**



- **`#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](14.Code_Convention.pdf)**



* **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](15.Debugging.pdf)**



* **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](16.Ecosystem.pdf)**



- **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](17.Utilities.pdf)**



* **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++ ``, 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](18.Iterators_Containers_Alg.pdf)**



* **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](19.Advanced_Topics_I.pdf)**



* **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](20.Advanced_Topics_II.pdf)**



- **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](21.Optimization_I.pdf)**



* **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](22.Optimization_II.pdf)**



* **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](23.Optimization_III.pdf)**



* **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)](24.Software_Design_I.pdf)**



- **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)](25.Software_Design_II.pdf)**



- **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/](https://www.linkedin.com/in/federico-busato/)

- Twitter: [twitter.com/fedebusato](https://twitter.com/fedebusato)