{"id":15035125,"url":"https://github.com/federico-busato/modern-cpp-programming","last_synced_at":"2025-05-08T22:26:25.480Z","repository":{"id":37544873,"uuid":"124365799","full_name":"federico-busato/Modern-CPP-Programming","owner":"federico-busato","description":"Modern C++ Programming Course (C++03/11/14/17/20/23/26)","archived":false,"fork":false,"pushed_at":"2025-04-14T19:47:52.000Z","size":576695,"stargazers_count":13199,"open_issues_count":2,"forks_count":901,"subscribers_count":143,"default_branch":"master","last_synced_at":"2025-05-08T20:55:45.839Z","etag":null,"topics":["c-plus-plus","code-quality","compilers","course","courses","cpp","cpp-programming","cpp03","cpp11","cpp14","cpp17","cpp20","cpp23","cpp26","debugging","optimization","programming","template"],"latest_commit_sha":null,"homepage":"https://federico-busato.github.io/Modern-CPP-Programming/","language":"HTML","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/federico-busato.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2018-03-08T09:06:52.000Z","updated_at":"2025-05-08T16:11:53.000Z","dependencies_parsed_at":"2022-07-12T16:22:21.993Z","dependency_job_id":"67a02912-3807-478a-910f-c27e7110895e","html_url":"https://github.com/federico-busato/Modern-CPP-Programming","commit_stats":null,"previous_names":[],"tags_count":14,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/federico-busato%2FModern-CPP-Programming","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/federico-busato%2FModern-CPP-Programming/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/federico-busato%2FModern-CPP-Programming/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/federico-busato%2FModern-CPP-Programming/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/federico-busato","download_url":"https://codeload.github.com/federico-busato/Modern-CPP-Programming/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":253156720,"owners_count":21862991,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["c-plus-plus","code-quality","compilers","course","courses","cpp","cpp-programming","cpp03","cpp11","cpp14","cpp17","cpp20","cpp23","cpp26","debugging","optimization","programming","template"],"created_at":"2024-09-24T20:27:36.070Z","updated_at":"2025-05-08T22:26:25.439Z","avatar_url":"https://github.com/federico-busato.png","language":"HTML","readme":"# Modern C++ Programming\n\n\u003cp align=\"center\"\u003e\n\u003cimg src=\"other/cpp_logo.png\" /\u003e\n\u003c/p\u003e\n\u003cp align=\"center\"\u003e\n    \u003ca href=\"https://github.com/federico-busato/Modern-CPP-Programming/releases\" alt=\"Release\"\u003e\n        \u003cimg src=\"https://img.shields.io/github/v/release/federico-busato/Modern-CPP-Programming?style=for-the-badge\"/\u003e\n    \u003c/a\u003e\n\u003c/p\u003e\n\n\u003cp align=\"center\"\u003e\n    \u003ca alt=\"Stars\"\u003e\n        \u003cimg src=\"https://img.shields.io/github/stars/federico-busato/Modern-CPP-Programming?style=for-the-badge\"/\u003e\n    \u003c/a\u003e\n    \u003ca href=\"https://github.com/federico-busato/Modern-CPP-Programming/network/members\" alt=\"Forks\"\u003e\n        \u003cimg src=\"https://img.shields.io/github/forks/federico-busato/Modern-CPP-Programming?style=for-the-badge\"/\u003e\n    \u003c/a\u003e\n\u003c/p\u003e\n\u003cp align=\"center\"\u003e\n    \u003ca href=\"https://github.com/federico-busato/Modern-CPP-Programming/commits/master\" alt=\"Commits\"\u003e\n        \u003cimg src=\"https://badgen.net/github/commits/federico-busato/Modern-CPP-Programming?style=for-the-badge\u0026scale=1.2\"/\u003e\n    \u003c/a\u003e\n\u003c/p\u003e\n\u003cp align=\"center\"\u003e\n    \u003ca href=\"https://github.com/federico-busato/Modern-CPP-Programming-Material/issues\" alt=\"Issues\"\u003e\n        \u003cimg src=\"https://badgen.net/github/closed-issues/federico-busato/Modern-CPP-Programming?style=for-the-badge\u0026scale=1.2\"/\u003e\n    \u003c/a\u003e\n\u003c/p\u003e\n\n## C++03 / C++11  /  C++14  /  C++17  / C++20 / C++23 / C++26\n\nThis *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.\n\n**Key features**:\n\n- *Free and frequently updated*\n- *26 lectures, 1800+ slides*\n- Include the *last language standard* concepts and features\n- *Practical teaching*: non-verbose, short structured descriptions associated with code\n- *Minimal code examples* for showing just a specific feature or issue without digressing\n- *Complementary language aspects*: tools, coding conventions, project organization, and code optimization\n- *Experience-based*: many aspects, examples, and problems come from real-world cases faced during my work as software engineer\n\n*If you enjoy the course or you find it useful*, please add a **Star**\n\n [![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)\n\n## CHAPTERS\n\n| #      | TITLE                                                                                                                                                                                  | MAIN FOCUS                                                                                     |\n| ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |\n| **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                                   |\n| **2**  | [**Preparation**](02.Preparation.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/02.Preparation.html))                                                     | Books, How to compile, Hello world                                                             |\n| **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                                                  |\n| **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                                         |\n| **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                                     |\n| **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                      |\n| **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                                        |\n| **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                                       |\n| **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                                                            |\n| **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                                         |\n| **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                                                                         |\n| **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                                                                |\n| **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                          |\n| **14** | [**Code Conventions I**](14.Code_Convention_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Code_Convention_I.html))                                  | Project organization, code conventions intro, entities conventions                             |\n| **15** | [**Code Conventions II**](15.Code_Convention_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/15.Code_Convention_II.html))                               | Template, namespace, modern c++, maintainability , naming, and formatting conventions          |\n| **16** | [**Debugging and Testing**](16.Debugging.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/16.Debugging.html))                                               | Execution/memory debugging, Sanitizers, Harding techniques, Unit test, Test-Driven Development |\n| **17** | [**Ecosystem**](17.Ecosystem.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Ecosystem.html))                                                           | Cmake, Documenting, and Other Tools                                                            |\n| **18** | [**Utilities**](18.Utilities.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/18.Utilities.html))                                                           | Main `std` libraries                                                                           |\n| **19** | [**Containers, Iterators, and Algorithms**](19.Iterators_Containers_Alg.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Iterators_Containers_Alg.html)) | Containers, Iterators, Algorithms, Ranges                                                      |\n| **20** | [**Advanced Topics I**](20.Advanced_Topics_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Advanced_Topics_I.html))                                   | Move semantics, Universal reference, Type deduction                                            |\n| **21** | [**Advanced Topics II**](21.Advanced_Topics_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_II.html))                                | Error handling, C++ idioms, Smart pointers                                                     |\n| **22** | [**Performance Optimizations I**](22.Optimization_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Optimization_I.html))                               | Ahmdal Law, Performance bounds, Architecture concepts (ILP, SIMD, etc.), Memory hierarchy      |\n| **23** | [**Performance Optimizations II**](23.Optimization_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_II.html))                            | Arithmetic optimizations, Memory optimizations, etc.                                           |\n| **24** | [**Performance Optimizations III**](24.Optimization_III.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/24.Optimization_III.html))                         | Compiler optimizations, Profiling, Benchmarking tools                                          |\n| **25** | [**Software Design I**](25.Software_Design_I.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Software_Design_I.html))                                   | Basic Concepts, Principles, Use cases                                                          |\n| **26** | [**Software Design II**](26.Software_Design_II.pdf) ([html](https://federico-busato.github.io/Modern-CPP-Programming/htmls/26.Software_Design_II.html))                                | Design Patterns and Idioms                                                                     |\n\n***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)\n\n## TOPICS IN DETAILS\n\n**[1. Introduction](01.Introduction.pdf)**\n\n* **A Little History of C/C++ Programming Languages**\n* **Areas of Application and Popularity**\n* **C++ Philosophy**\n* **C++ Weakness**: C++ alternatives, Why switching to a new language is hard?\n* **The Course**\n\n**[2. Preparation](02.Preparation.pdf)**\n\n- **Books and References**\n- **Slide Legend**\n- **What Editor/ IDE/Compiler Should I Use?**\n- **How to compile?**\n- **Hello World**: I/O Stream\n\n**[3. Basic Concepts I - Type System, Fundamental Types, and Operators](03.Basic_Concepts_I.pdf)**\n\n* **The C++ Type System**: Type categories, Type properties\n* **C++ Fundamental Types Overview**: Arithmetic types, Suffix and prefix, Non-standard arithmetic types, `void` type, `nullptr`\n* **Conversion Rules**\n* **`auto` Keyword**\n* **C++ Operators**: Operators precedence, Prefix/Postfix increment/decrement semantic, Assignment, compound, and comma operators, Spaceship operator `\u003c=\u003e` , Safe comparison operators\n\n**[4. Basic Concepts II - Integral and Floating-point Types](04.Basic_Concepts_II.pdf)**\n\n* **Integral Data Types**: Fixed width integers, `size_t`, `ptrdiff_t`, `uintptr_t`,  Arithmetic Operation Semantics, Promotion, Truncation, Undefined behavior, Saturation Arithmentic\n* **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\n* **Floating-point Issues**: Catastrophic cancellation, Floating-point comparison\n\n**[5. Basic Concepts III - Entities and Control Flow](05.Basic_Concepts_III.pdf)**\n\n* **Entities**\n* **Declaration and Definition**\n* **Enumerators**\n* **`struct`, Bitfield, `union`**\n* **Control Flow**: `if` statement, `for` and `while` loops, Range-base `for` loop, `switch`, `goto`, Avoid unused variable warning\n* **Namespace**: Explicit global namespace, namespace alias, `using`-declaration, `using namespace`-directive, `inline` namespace\n* **Attributes**: `[[nodiscard]]`, `[[maybe_unused]]`, `[[deprecated]]`, `[[noreturn]]`\n\n**[6. Basic Concepts IV - Memory Concepts](06.Basic_Concepts_IV.pdf)**\n\n* **Pointers**: Pointer operations, Address-of operator `\u0026`, `struct` member access, `void` pointer, Pointer conversion, Pointer arithmetic, Wild and dangling pointers\n* **Heap and Stack**: Stack memory, `new`, `delete`, Non-allocating placement allocation, Non-throwing allocation, Memory leak\n* **Initialization**: Variable initialization, Uniform initialization, Array initialization, Structure initialization, Structure Binding, Dynamic memory initialization\n* **References**\n* **`Const` and Constant Expressions**: Contants and literals, `const`, `constexpr`, `consteval`, `constinit`, `if constexpr`, `std::is constant evaluated()`, `if consteval`\n* **`volatile` keyword**\n* **Explicit Type Conversion**: `static_cast`, `const_cast`, `reinterpret_cast`, Type punning, `std::bit_cast`, Uniform initialization conversion, `gls::narrow_cast`\n* **`sizeof` Operator**: overview, `[[no_unique_address]]`\n\n**[7. Basic Concepts V - Functions and Preprocessing](07.Basic_Concepts_V.pdf)**\n\n* **Functions**: Pass-by-value, Pass-by-pointer, Pass-by-reference, Function signature and overloading, Overloading and `=delete`, Default parameters\n* **Function Pointer and Function Objects**\n* **Lambda Expressions**: Capture list, Lambda expression and function relation, Parameter notes, Composability, Recursion,  `constexpr/consteval`, `template`, `mutable`, `[[nodiscard]]`, Capture list and classes\n* **Preprocessing**: Preprocessors, Common errors, Source location macros, Conditional compiling macros, Stringizing operator (`#`),  `#error` and `#warning`, `#pragma`, Token-pasting operator `##`, Variadic macro\n\n**[8. Object-Oriented Programming I - Class Concepts](08.Object_Oriented_I.pdf)**\n\n* **C++ Classes**: RAII idiom\n* **Class Hierarchy**\n* **Access specifiers**: Inheritance access specifiers, When use `public/protected/private` for data members?\n* **Class Constructor**: Default constructor, Class initialization, Uniform initialization for objects, Delegate constructor, `explicit` keyword, `[[nodiscard]]` and classes\n* **Copy Constructor**\n* **Class Destructor**\n* **Defaulted  Constructors, Destructor, and Operators** (`= default`)\n* **Class Keywords**: `this`, `static`, `const`, `mutable`, `using`, `friend`, `delete`\n\n**[9. Object-Oriented Programming II - Polymorphism and Operator Overloading](09.Object_Oriented_II.pdf)**\n\n* **Polymorphism**: C++ mechanisms for polymorphism, `virtual` methods, Virtual table, `override` keyword, `final` keyword, Common errors, Pure virtual method, Abstract class and interface\n* **Inheritance Casting and Run-time Type Identification**\n* **Operator Overloading**: Overview, Comparison operator `\u003c`, Spaceship operator `\u003c=\u003e`, 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 `\u003c\u003c`, Operator notes\n* **C++ Object Layout**: Aggregate, Trivial class, Standard-layout class, Plain old data (POD), Hierarchy\n\n**[10. Templates and Meta-programming I - Function Templates and Compile-Time Utilities](10.Templates_I.pdf)**\n\n* **Function Template**: Overview, Template instantiation, Templat parameters, Template parameter - default value, Overloading, Specialization\n* **Template Variable**\n* **Template Parameter Types**: Generic Type Notes, `auto` Placeholder, Class template parameter type, Array and pointer types, Function type\n* **Compile-Time Utilities**: `static_assert`, `using` keyword, `decltype` keyword\n* **Type Traits**: Overview, Type traits library, Type manipulation\n\n**[11. Templates and Meta-programming II - Class Templates and SFINAE](11.Templates_II.pdf)**\n\n* **Class Template**: Class specialization, Class template constructor\n* **Constructor template automatic deduction (CTAD)**\n* **Class Template - Advanced Concepts**: Class + Function - specialization, Dependent names - `typename` and `template` keywords, Class template hierarchy and `using`, `friend` keyword, Template template arguments\n* **Template Meta-Programming**\n* **SFINAE: Substitution Failure Is Not An Error**: Function SFINAE, Class SFINAE\n* **Variadic Template**: Folding expression, Variadic class template\n* **C++20 Concepts**: Overview, `concept` keyword, `requires` clause, `requires` expression, `requires` expression + clause, `requires` clause + expression, `requires` and `constexpr`, Nested `requires`\n* **Template Debugging**\n\n**[12. Translation Units I - Linkage and One Definition Rule](12.Translation_Units_I.pdf)**\n\n* **Basic Concepts**: Translation unit, Local and global scope, Linkage\n* **Storage Class and Duration**: Storage duration, Storage class, `static` keyword, Anonymous namespace, `extern` keywords\n* **Linkage of `const` and `constexpr`**: Static initialization order fiasco\n* **Linkage Summary**\n* **Dealing with Multiple Translation Units**: Class in multiple translation units\n* **One Definition Rule (ODR)**: Global variable issues, ODR - Point 3, `inline` functions/variables, `constexpr` and `inline`\n* **ODR - Function Template**: Cases, `extern` keyword\n* **ODR - Class Template**: Cases, `extern` keyword\n* **ODR Undefined Behavior and Summary**\n\n**[13. Translation Units II - Include, Module, and Namespace](13.Translation_Units_II.pdf)**\n\n- **`#include` Issues**: Include guard, Forward declaration, Circular dependencies, Common linking errors\n- **C++20 Modules**: Overview, Terminology, Visibility and reachability, Module unit types, Keywords, Global module fragment, Private module fragment, Header module unit, Module partitions\n- **Compiling Multiple Translation Units**: Fundamental compiler flags, Compile Methods\n- **Libraries in C++**: Static library, Build static libraries, Using static libraries, Dynamic library, Build dynamic libraries, Using dynamic libraries, Application binary interface (ABI), Demangling, Find Dynamic library dependencies, Analyze object/executable symbols\n\n**[14. Code Conventions I](14.Code_Convention_I.pdf)**\n\n* **C++ Project Organization**: Project directories, Project files, \"Common\" project organization notes, Alternative - “Canonical” project organization\n* **Coding Styles and Conventions**: Overview, Popular coding styles\n* **Header Files and `#include`**: `#include` guard, `#include` syntax, order of `#include`, Common header/source filename conventions\n* **Preprocessing**: Macro, Preprocessing statements\n* **Variables**: `static` global variables, conversions\n* **Enumerators**\n* **Arithmetic Types**: Signed vs. unsigned integral types, integral types conversion, Integral types: size and other issues, Floating-point types\n* **Functions**: Function parameters, Function arguments, function return values, Function specifiers, lambda expressions\n* **Structs and Classes**: `struct` vs `class`, Initialization, Braced initializer lists, Special member functions, `=default`, `=delete`, Other issues, Inheritance, Style\n\n**[15. Code Conventions II](15.Code_Convention_II.pdf)**\n\n- **`auto`**\n- **Templates and Type Deduction**\n- **Control Flow**: Redundant control flow , `if/else`, Comparison, `switch`, `for/while`\n- **Namespace**: `using namespace` directive, Anoymous/unnamed namespace, Namespace and class design, Style\n- **Modern C++ Features**: Keywords, Features, Class, Library\n- **Maintainability**: Code comprehension, Functions, Template and Debuction, Library\n- Portability\n- **Naming**: Entities, Variables, Functions, Style conventions, Enforcing naming styles\n- **Readability and Formatting**: Horizontal spacing, Pointers/References, Vertical spacing, Braces, Type decorators, Reduce code verbosity, Other issues\n- **Code Documentation**: Function documentation, Comment syntax, File documentation\n\n**[16. Debugging and Testing](16.Debugging.pdf)**\n\n* **Debugging Overview**\n* **Assertions**\n* **Execution debugging**: Breakpoints, Watchpoints / Catchpoints, Control flow, Stack and info, Print, Disassemble, `std::breakpoint`\n* **Memory Debugging**: `valgrind`\n* **Hardening Techniques**: Stack usage, Standard library checks, Undefined behavior protections, Control flow protections\n* **Sanitizers**: Address sanitizer, Leak sanitizer, Memory sanitizers, Undefined behavior sanitizer, Sampling-baed sanitizer\n* **Debugging Summary**\n* **Compiler Warnings**\n* **Static Analysis**\n* **Code Testing**: Unit testing, Test-Driven Development (TDD), Code coverage, Fuzz testing\n* **Code Quality**: `clang-tidy`\n\n**[17. Ecosystem - Cmake and Other Tools](17.Ecosystem.pdf)**\n\n- **CMake**: `cmake` and `ctest`\n- **Code Documentation**: `doxygen`\n- **Code Statistics**: Count lines of code, Cyclomatic complexity analyzer\n- **Other Tools**: Code formatting - `clang-format`, `Compiler Explorer`, Code transformation - `CppInsights`, AI-powered code completion -Local code search - `ugrep`, `ripgrep`, `hypergrep`, Code search engine - `searchcode/grep.app`, Code benchmarking - `Quick-Bench`, Font for coding\n\n**[18. Utilities](18.Utilities.pdf)**\n\n* **I/O Stream**: Manipulator, `ofstream/ifstream`\n* **Strings**: `std::string`, Conversion from/to numeric  values, `std::string_view`, `std::format`, `std::print`\n* **View**: `std::span`\n* **Math Libraries**\n* **Random Number**: Basic concepts, C++ `\u003crandom\u003e`, Seed, PRNG period and quality, Distribution, Recent algorithms and Performance, Quasi-random\n* **Time Measuring**: Wall-Clock time, User time, System time\n* **Std Class Templates**: `std::pair`, `std::tuple`, `std::variant`, `std::optional`, `std::any`, `std::stacktrace`\n* **Filesystem Library**: Query methods, Modify methods\n\n**[19. Containers, Iterators, and Algorithms](19.Iterators_Containers_Alg.pdf)**\n\n* **Containers and Iterators**\n* **Sequence Containers**: `std::array`, `std::vector`, `std::deque`, `std::list`, `std::forward_list`\n* **Associative Containers**: `std::set`, `std::map`, `std::multiset`\n* **Container Adaptors**: `std::stack`, `std::queue`, `std::priority_queue`\n* **Implement a Custom Iterator**: Implement a simple Iterator\n* **Iterator Notes**:\n* **Iterator Utility Methods**: `std::advance`, `std::next`, `std::prev`, `std::distance`, Container access methods, Iterator traits\n* **Algorithms Library**: `std::find_if`, `std::sort`, `std::accumulate`, `std::generate`, `std::remove_if`\n* **C++20 Ranges**: Key concepts, Range view,  Range adaptor, Range factory, Range algorithms, Range actions\n\n**[20. Advanced Topics I](20.Advanced_Topics_I.pdf)**\n\n* **Move Semantic**: `lvalues` and `rvalues` references, Move semantic, `std::move`, Class declaration semantic\n* **Universal Reference and Perfect Forwarding**: Universal reference, Reference collapsing rules, Perfect forwarding\n* **Value Categories**\n* **`\u0026`, `\u0026\u0026` Ref-qualifiers and `volatile` Overloading**\n* **Copy Elision and RVO**\n* **Type Deduction**: Pass by-reference, Pass-by-pointer, Pass-by-value, `auto` deduction, `auto(x)`: Decay-copy\n* **`const` Correctness**\n\n**[21. Advanced Topics II](21.Advanced_Topics_II.pdf)**\n\n- **Undefined Behavior:** Illegal behavior, Platform specific behavior, unspecified behavior, Detecting undefined behavior\n- **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\n- **Smart pointers**: `std::unique_ptr`, `std::shared_ptr`, `std::weak_ptr`\n- **Concurrency**: Thread methods, Mutex, Atomic, Task-based parallelism\n\n**[22. Optimization I - Basic Concepts](22.Optimization_I.pdf)**\n\n* **Introduction**: Moore's Law, Moore's Law limitations, Reasons for optimizing\n* **Basic Concepts**: Asymptotic complexity, Time-Memory trade-off, Developing cycle, Ahmdal's law, Throughput, Bandwidth, Latency, Performance bounds, Arithmetic intensity\n* **Basic Architecture Concepts**: Instruction throughput (IPC), In-Order, and Out-of-Order Execution, Instruction pipelining, Instruction-level parallelism (ILP), Little’s law, Data-level parallelism (DLP) and vector instructions (SIMD), Thread-level parallelism (TLP), Single Instruction Multiple Threads (SIMT), RISC, CISC instruction sets\n* **Memory Hierarchy**: Memory hierarchy concepts, Memory locality, Core-to-core latency and thread affinity, Memory ordering model\n\n**[23. Optimization II - Code Optimization](23.Optimization_II.pdf)**\n\n* **I/O Operations**: `printf`, Memory mapped I/O, Speed up raw data loading\n* **Memory Optimizations**: Heap memory, Stack memory, Cache utilization, Data alignment, Memory Prefetch\n* **Arithmetic Types**: Data types, Arithmetic operations, Conversion, Floating-point, Compiler intrinsic functions, Value in a range, Lookup table\n* **Control Flow**: Branhes, Branch Hints - `[[likely]]` / `[[unlikely]]`, Signed/Unsigned integers, Loops, Loop hoisting, Loop unrolling, Assertions, Compiler hints `[[assume]]/std::unreacheable()`, Recursion\n* **Functions**: Function call cost, Argument passing, Function inlining, Function attributes, Pointers aliasing\n* **Object-Oriented Programming**\n* **Std Library and Other Language Aspects**\n\n**[24. Optimization III - Non-Coding Optimizations and Benchmarking](24.Optimization_III.pdf)**\n\n* **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, Polyhedral optimizations\n* **Compiler Transformation Techniques**: Basic transformations, Loop unswitching, Loop fusion, Loop fission, Loop interchange, Loop tiling\n* **Libraries and Data Structures**\n* **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\n* **Profiling**: `gprof`, `uftrace`, `callgrind`, `cachegrind`, `perf` Linux profiler\n* **Parallel Computing**: Concurrency vs. parallelism, Performance scaling, Gustafson's Law, Parallel programming languages\n\n**[25. Software Design I - Basic Concepts (DRAFT)](25.Software_Design_I.pdf)**\n\n- **Books and References**\n- **Basic Concepts**: Abstraction, interface, and module, Class Invariant\n- **Software Design Principles**: Separation of concern, Low coupling, high cohesion, Encapsulation and information hiding, Design by contract, Problem decomposition, Code reuse\n- **Software Complexity**: Software entropy, Technical debt\n- **The SOLID Design Principles**\n- **Class Design**: The class interface principle, Member functions vs. free functions, namespace functions vs. class static methods\n- **BLAS GEMM Case Study**\n- **Owning Objects and Views**\n- **Value vs. Reference Semantic**\n- **Global Variables**\n\n**[26. Software Design II - Design Patterns and Idioms (DRAFT)](26.Software_Design_II.pdf)**\n\n- **C++ Idioms**: Rule of Zero, Rule of Three, Rule of Five\n- **Design Pattern**: Singleton, Pointer to implementation (PIMPL), Curiously Recurring Template Pattern (CRTP), Template virtual functions\n\n### Roadmap\n\n1. Improve Software Design Chapters\n2. Build Aspects Chapter (e.g. reducing build time)\n\n### Reporting bugs 🐛 and contributing\n\nIf you find any typo, conceptual error, or section to improve, please report them by using the `issue` panel.\n\n## Author\n\n`Federico Busato`, https://federico-busato.github.io/\n\n- \u0026#127760; LinkedIn: [www.linkedin.com/in/federico-busato/](https://www.linkedin.com/in/federico-busato/)\n- \u0026#129419; Bluesky: [fbusato.bsky.social](https://bsky.app/profile/fbusato.bsky.social)\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ffederico-busato%2Fmodern-cpp-programming","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ffederico-busato%2Fmodern-cpp-programming","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ffederico-busato%2Fmodern-cpp-programming/lists"}