[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-70895":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":16,"subscribersCount":16,"size":16,"stars1d":17,"stars7d":18,"stars30d":19,"stars90d":16,"forks30d":16,"starsTrendScore":20,"compositeScore":21,"rankGlobal":10,"rankLanguage":10,"license":22,"archived":23,"fork":23,"defaultBranch":24,"hasWiki":23,"hasPages":25,"topics":26,"createdAt":10,"pushedAt":10,"updatedAt":45,"readmeContent":46,"aiSummary":47,"trendingCount":16,"starSnapshotCount":16,"syncStatus":48,"lastSyncTime":49,"discoverSource":50},70895,"Modern-CPP-Programming","federico-busato\u002FModern-CPP-Programming","federico-busato","Modern C++ Programming Course (C++03\u002F11\u002F14\u002F17\u002F20\u002F23\u002F26)","https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002F",null,"HTML",15734,1112,157,3,0,13,42,189,39,44.14,"Creative Commons Attribution Share Alike 4.0 International",false,"master",true,[27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44],"c-plus-plus","code-quality","compilers","course","courses","cpp","cpp-programming","cpp03","cpp11","cpp14","cpp17","cpp20","cpp23","cpp26","debugging","optimization","programming","template","2026-06-12 02:02:44","# Modern C++ Programming\n\n\u003Cp align=\"center\">\n\u003Cimg src=\"other\u002Fcpp_logo.png\" \u002F>\n\u003C\u002Fp>\n\u003Cp align=\"center\">\n    \u003Ca href=\"https:\u002F\u002Fgithub.com\u002Ffederico-busato\u002FModern-CPP-Programming\u002Freleases\" alt=\"Release\">\n        \u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fgithub\u002Fv\u002Frelease\u002Ffederico-busato\u002FModern-CPP-Programming?style=for-the-badge\"\u002F>\n    \u003C\u002Fa>\n\u003C\u002Fp>\n\n\u003Cp align=\"center\">\n    \u003Ca alt=\"Stars\">\n        \u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fgithub\u002Fstars\u002Ffederico-busato\u002FModern-CPP-Programming?style=for-the-badge\"\u002F>\n    \u003C\u002Fa>\n    \u003Ca href=\"https:\u002F\u002Fgithub.com\u002Ffederico-busato\u002FModern-CPP-Programming\u002Fnetwork\u002Fmembers\" alt=\"Forks\">\n        \u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fgithub\u002Fforks\u002Ffederico-busato\u002FModern-CPP-Programming?style=for-the-badge\"\u002F>\n    \u003C\u002Fa>\n\u003C\u002Fp>\n\u003Cp align=\"center\">\n    \u003Ca href=\"https:\u002F\u002Fgithub.com\u002Ffederico-busato\u002FModern-CPP-Programming\u002Fcommits\u002Fmaster\" alt=\"Commits\">\n        \u003Cimg src=\"https:\u002F\u002Fbadgen.net\u002Fgithub\u002Fcommits\u002Ffederico-busato\u002FModern-CPP-Programming?style=for-the-badge&scale=1.2\"\u002F>\n    \u003C\u002Fa>\n\u003C\u002Fp>\n\u003Cp align=\"center\">\n    \u003Ca href=\"https:\u002F\u002Fgithub.com\u002Ffederico-busato\u002FModern-CPP-Programming\u002Fissues\" alt=\"Issues\">\n        \u003Cimg src=\"https:\u002F\u002Fbadgen.net\u002Fgithub\u002Fclosed-issues\u002Ffederico-busato\u002FModern-CPP-Programming?style=for-the-badge&scale=1.2\"\u002F>\n    \u003C\u002Fa>\n\u003C\u002Fp>\n\n## C++03 \u002F C++11 \u002F C++14 \u002F C++17 \u002F C++20 \u002F C++23 \u002F C++26\n\nThis *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.\n\n**Key features**:\n\n- *Free and frequently updated*\n- *29 lectures, 2000+ slides*\n- Includes the *latest 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 a 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:\u002F\u002Fimg.shields.io\u002Fgithub\u002Fstars\u002Ffederico-busato\u002FModern-CPP-Programming?style=social)](https:\u002F\u002Fgithub.com\u002Ffederico-busato\u002FModern-CPP-Programming)\n\n**Roadmap**:\n\n1. Move from Latex to [Typst](https:\u002F\u002Ftypst.app\u002F).\n2. Fully-open source the material and allow direct contribution.\n\n## Table of Contents\n\n- [Chapters](#chapters)\n- [Topics in Details](#topics-in-details)\n- [Reporting Bugs 🐛 and Contributing](#reporting-bugs--and-contributing)\n- [Where the Course has been used](#where-the-course-has-been-used)\n- [License](#license)\n- [Author](#author)\n\n## CHAPTERS\n\n| #      | TITLE                                                                                                                                                                                  | MAIN FOCUS                                                                                     |\n| ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |\n| **1**  | [**Introduction**](01.Introduction.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F01.Introduction.html))                                                  | History of C\u002FC++, Areas of applications, Course introduction                                   |\n| **2**  | [**Preparation**](02.Preparation.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F02.Preparation.html))                                                     | Books, How to compile, Hello world                                                             |\n| **3**  | [**Basic Concepts I**](03.Basic_Concepts_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F03.Basic_Concepts_I.html))                                      | Type System, Fundamental types, and Operators                                                  |\n| **4**  | [**Basic Concepts II**](04.Basic_Concepts_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F04.Basic_Concepts_II.html))                                   | Integral types and arithmetic                                                                  |\n| **5**  | [**Basic Concepts III**](05.Basic_Concepts_III.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F05.Basic_Concepts_III.html))                                | Floating-point types and arithmetic                                                            |\n| **6**  | [**Basic Concepts IV**](06.Basic_Concepts_IV.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F06.Basic_Concepts_IV.html))                                   | Entities, Enumerators, Structures, Control flow statements                                     |\n| **7**  | [**Basic Concepts V**](07.Basic_Concepts_V.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F07.Basic_Concepts_V.html))                                      | Heap, Stack, Pointers, References, Const properties, Conversion operators                      |\n| **8**  | [**Basic Concepts VI**](08.Basic_Concepts_VI.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F08.Basic_Concepts_VI.html))                                   | Functions, Lambda expressions, Preprocessing directives                                        |\n| **9**  | [**Object-Oriented Programming I**](09.Object_Oriented_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F09.Object_Oriented_I.html))                       | Class hierarchy, Constructor, Destructor, Class keywords                                       |\n| **10** | [**Object Oriented Programming II**](10.Object_Oriented_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F10.Object_Oriented_II.html))                    | Polymorphism, Operators overloading                                                            |\n| **11** | [**Templates and Meta-programming I**](11.Templates_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F11.Templates_I.html))                                | Function template, Type traits, Compile-time utilities                                         |\n| **12** | [**Templates and Meta-programming II**](12.Templates_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F12.Templates_II.html))                             | Class template, SFINAE                                                                         |\n| **13** | [**Translation Units I**](13.Translation_Units_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F13.Translation_Units_I.html))                             | Linkage and One Definition Rule                                                                |\n| **14** | [**Translation Units II**](14.Translation_Units_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F14.Translation_Units_II.html))                          | Dealing with multiple translation units and files,`#include`, Modules                          |\n| **15** | [**Code Conventions I**](15.Code_Convention_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F15.Code_Convention_I.html))                                  | Project organization, Code conventions intro, Entities conventions                             |\n| **16** | [**Code Conventions II**](16.Code_Convention_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F16.Code_Convention_II.html))                               | Template, Namespace, Modern C++, Maintainability, Naming, and Formatting conventions           |\n| **17** | [**Debugging and Testing**](17.Debugging.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F17.Debugging.html))                                               | Execution\u002Fmemory debugging, Sanitizers, Hardening techniques, Unit tests, Test-Driven Development |\n| **18** | [**Ecosystem**](18.Ecosystem.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F18.Ecosystem.html))                                                           | Cmake, Documenting, and Other Tools                                                            |\n| **19** | [**Utilities**](19.Utilities.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F19.Utilities.html))                                                           | Main `std` libraries                                                                           |\n| **20** | [**Containers, Iterators, and Algorithms**](20.Iterators_Containers_Alg.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F20.Iterators_Containers_Alg.html)) | Containers, Iterators, Algorithms, Ranges                                                      |\n| **21** | [**Advanced Topics I**](21.Advanced_Topics_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F21.Advanced_Topics_I.html))                                   | Move semantics, Universal reference, Type deduction                                            |\n| **22** | [**Advanced Topics II**](22.Advanced_Topics_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F22.Advanced_Topics_II.html))                                | Error handling, C++ idioms, Smart pointers                                                     |\n| **23** | [**Performance Optimizations I**](23.Optimization_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F23.Optimization_I.html))                               | Amdahl's Law, Performance bounds, Architecture concepts (ILP, SIMD, etc.), Memory hierarchy    |\n| **24** | [**Performance Optimizations II**](24.Optimization_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F24.Optimization_II.html))                            | Arithmetic optimizations, Memory optimizations, etc.                                           |\n| **25** | [**Performance Optimizations III**](25.Optimization_III.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F25.Optimization_III.html))                         | Compiler optimizations, Profiling, Benchmarking tools                                          |\n| **26** | [**Software Design I**](26.Software_Design_I.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F26.Software_Design_I.html))                                   | Basic Concepts, Principles, Use cases                                                          |\n| **27** | [**Software Design II**](27.Software_Design_II.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F27.Software_Design_II.html))                                | Design Patterns and Idioms                                                                     |\n| **28** | [**Binary Size**](28.Binary_Size.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F28.Binary_Size.html))                                                     | Binary size aspects                                                                            |\n| **29** | [**Build Time**](29.Build_time.pdf) ([html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002F29.Build_time.html))                                                        | Build time aspects                                                                             |\n\n***ALL-IN-ONE BOOK***: [**modern-cpp.pdf**](modern-cpp.pdf) (could be a few commits behind), [html](https:\u002F\u002Ffederico-busato.github.io\u002FModern-CPP-Programming\u002Fhtmls\u002Fmodern-cpp.html)\n\n## TOPICS IN DETAILS\n\n**[1. Introduction](01.Introduction.pdf)**\n\n* **A Little History of C\u002FC++ 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\u002F IDE\u002FCompiler Should I Use?**.\n- **How to compile?**.\n- **Hello World**: I\u002FO 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, Non-standard arithmetic types, `void` type, `nullptr`.\n* **`auto` Keyword**.\n* **C++ Operators**: Operators precedence, Prefix\u002FPostfix increment\u002Fdecrement semantic, Assignment, compound, and comma operators, Spaceship operator `\u003C=>`.\n\n**[4. Basic Concepts II - Integral Types](04.Basic_Concepts_II.pdf)**\n\n* **Integral Data Types**: Suffix and Prefix, Fixed width integers, `size_t`, `ptrdiff_t`, `uintptr_t`.\n* **Arithmetic Operation Semantics**: Saturation Arithmetic.\n* **Integer Undefined behavior**: Signed overflow, Other cases.\n* **Integer Conversion Rules**: Same size conversion, Integer conversion rule, Arithmetic operation promotion rules, Safe comparison functions, Arithmetic operation special cases.\n\n**[5. Basic Concepts III - Floating-point Types](05.Basic_Concepts_III.pdf)**\n\n* **Floating-point Types**: Suffix, IEEE Floating-point standard and other representations, Normal\u002FDenormal 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**[6. Basic Concepts IV - Entities and Control Flow](06.Basic_Concepts_IV.pdf)**\n\n* **Entities**.\n* **Declaration and Definition**.\n* **Enumerators**.\n* **`struct`, Bitfield, `union`**: `struct`, Anonymous and unnamed `struct`, Bitfield, `union`.\n* **Control Flow**: `if` statement, `for` and `while` loops, Range-based `for` loop, `switch`, Initializing statement, `goto`, Avoid unused variable warning.\n* **Namespace**: Explicit global namespace, namespace alias, `using`-declaration, `using namespace`-directive, `inline` namespace.\n* **Attributes**: `[[nodiscard]]`, `[[indeterminate]]`, `[[maybe_unused]]`, `[[deprecated]]`, `[[noreturn]]`.\n\n**[7. Basic Concepts V - Memory Concepts](07.Basic_Concepts_V.pdf)**\n\n* **Pointers**: Pointer operations, Address-of operator `&`, `struct` member access, `void` pointer, Pointer conversion, Pointer arithmetic, Wild and dangling pointers.\n* **Fixed-size Array**.\n* **References**.\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* **`Const` and Constant Expressions**: Constants and literals, `const`, `constexpr`, `constexpr` Variables, `constexpr` Functions, `constexpr` objects,  `consteval`, `constinit`.\n* **Conditional Constant Expressions**: \n*  `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` and `alignof` Operators**: `sizeof`, `alignof`, `sizeof\u002Falignof` operator applied to `struct`, `[[no_unique_address]]`.\n\n**[8. Basic Concepts VI - Functions and Preprocessing](08.Basic_Concepts_VI.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\u002Fconsteval`, `template`, `mutable`, 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**[9. Object-Oriented Programming I - Class Concepts](09.Object_Oriented_I.pdf)**\n\n* **C++ Classes**: RAII idiom.\n* **Class Hierarchy**.\n* **Access specifiers**: Inheritance access specifiers, When use `public\u002Fprotected\u002Fprivate` for data members?.\n* **Class Constructor**: Default constructor, Class initialization, Uniform initialization for objects, Delegate constructor, `explicit` keyword.\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**[10. Object-Oriented Programming II - Polymorphism and Operator Overloading](10.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=>`, Subscript operator `[]`, Multidimensional subscript operator `[]`, Function call operator `()`, static operator `[]` and operator `()`, Conversion operator `T()`, Return type overloading resolution, Increment and decrement operators `++`\u002F`--`, 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**[11. Templates and Meta-programming I - Function Templates and Compile-Time Utilities](11.Templates_I.pdf)**\n\n* **Function Template**: Overview, Template instantiation, Template parameters, Template parameter - default value, Overloading, Specialization.\n* **Template Variable**.\n* **Template Parameter Types**: Generic type notes, `auto` placeholder, Function type.\n* **Compile-Time Utilities**: `static_assert`, `using` keyword, `decltype` keyword.\n* **Type Traits**: Overview, Type traits library, Type manipulation.\n\n**[12. Templates and Meta-programming II - Class Templates and SFINAE](12.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**: Homogeneous variadic parameters, 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**[13. Translation Units I - Linkage and One Definition Rule](13.Translation_Units_I.pdf)**\n\n* **Basic Concepts**: Translation unit, Local and global scope, Linkage, Visibility.\n* **Storage Class and Duration**: Storage duration, Storage class, `static` keyword, Anonymous namespace, `extern` keyword.\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\u002Fvariables, `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**[14. Translation Units II - Include, Module, and Namespace](14.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\u002Fexecutable symbols.\n\n**[15. Code Conventions I](15.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\u002Fsource 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**[16. Code Conventions II](16.Code_Convention_II.pdf)**\n\n- **`auto`**.\n- **Templates and Type Deduction**.\n- **Control Flow**: Redundant control flow, `if\u002Felse`, Comparison, `switch`, `for\u002Fwhile`.\n- **Namespace**: `using namespace` directive, Anonymous\u002Funnamed namespace, Namespace and class design, Style.\n- **Modern C++ Features**: Keywords, Features, Class, Library.\n- **Maintainability**: Code comprehension, Functions, Template and deduction, Library.\n- **Portability**.\n- **Naming**: Entities, Variables, Functions, Style conventions, Enforcing naming styles.\n- **Readability and Formatting**: Horizontal spacing, Pointers\u002FReferences, Vertical spacing, Braces, Type decorators, Reduce code verbosity, Other issues.\n- **Code Documentation**: Function documentation, Comment syntax, File documentation.\n\n**[17. Debugging and Testing](17.Debugging.pdf)**\n\n* **Debugging Overview**: Errors, defects, and failures, Cost of software defects, Software defects classification,Program error and classification, Software defect analysis.\n* **Assertions**: Run-time assertions, Contracts, `std::stacktrace`.\n* **Execution debugging**: Breakpoints, Watchpoints \u002F Catchpoints, Control flow, Stack and info, Print, Disassemble, `std::breakpoint`.\n* **Memory Debugging**: `valgrind`.\n* **Hardening Techniques**: Stack usage, Standard C library hardening, Standard C++ library hardening,Undefined behavior protections, Control flow protections.\n* **Sanitizers**: Address sanitizer, Leak sanitizer, Memory sanitizers, Undefined behavior sanitizer, Type Sanitizer, Sampling-based sanitizer.\n* **Debugging Summary**.\n* **Compiler Warnings**.\n* **Static Analysis**: Compiler-provided static analyzers, Open-source static analyzers, Proprietary static analyzers.\n* **Code Testing**: Unit testing, Test-Driven Development (TDD), Code coverage, Fuzz testing.\n* **Code Quality**: `clang-tidy`.\n* **Code Complexity**: Cyclomatic complexity, Cognitive complexity.\n\n**[18. Ecosystem - Cmake and Other Tools](18.Ecosystem.pdf)**\n\n- **CMake**: `cmake` and `ctest`\n- **Code Documentation**: `doxygen`, Alternatives.\n- **Online Tools**: AI-Powered code completion\u002FIDE, Compilation and execution, Code transformation, Code benchmarking,\nCode search engine.\n- **Offline Tools**: Code formatting, Code statistics, AST diff, Project visualization, Local code search, AST search,\nFont for coding.\n\n**[19. Utilities](19.Utilities.pdf)**\n\n* **View Introduction and `std::span`**.\n* **`std::mdspan`**: `std::extends`, Layout, `std::layout_right`, `std::layout_left`, `std::layout_stride`, `std::layout_right_padded`, `std::layout_left_padded`, Accessor.\n* **Strings and `std::print`**: `std::string`, Conversion from\u002Fto numeric values, `std::string_view`, `std::format`, `std::print`.\n* **Math Libraries**: `\u003Ccmath>` Math Library, `\u003Climits>` Numerical Limits, `\u003Cnumbers>` Mathematical Constants.\n* **Random Number**: Basic concepts, C++ `\u003Crandom>`, Seed, PRNG period and quality, Distribution, Recent algorithms and Performance, Quasi-random, True Random Number Generator (TRNG).\n* **Time Measuring**: Wall-Clock time, User time, System time\n* **Std Class Templates**: `std::pair`, `std::tuple`, `std::variant`, `std::optional`, `std::any`.\n* **Filesystem Library**: Query methods, Modify methods.\n\n**[20. Containers, Iterators, and Algorithms](20.Iterators_Containers_Alg.pdf)**\n\n* **Containers and Iterators**: Semantic.\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**[21. Advanced Topics I](21.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* **`&`, `&&` 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**[22. Advanced Topics II](22.Advanced_Topics_II.pdf)**\n\n- **Undefined Behavior**: Illegal behavior, Platform specific behavior, unspecified behavior, Detecting undefined behavior.\n- **Error Handling**: Recoverable error handling, 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**[23. Optimization I - Basic Concepts](23.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, Amdahl'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**[24. Optimization II - Code Optimization](24.Optimization_II.pdf)**\n\n* **I\u002FO Operations**: `printf`, Memory mapped I\u002FO, Speed up raw data loading.\n* **Memory Optimizations**: Heap memory, Stack memory, `constexpr` vs. `static constexpr`, Cache utilization, Memory 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**: Branches, Branch Hints - `[[likely]]` \u002F `[[unlikely]]`, Signed\u002FUnsigned integers, Loops, Loop hoisting, Loop unrolling, Assertions, Compiler hints `[[assume]]\u002Fstd::unreachable()`, Recursion.\n* **Functions**: Function call cost, Argument passing, Function inlining, Pure functions, Constant functions, Pointer aliasing.\n* **Object-Oriented Programming**.\n* **Standard Library and Other Language Aspects**.\n\n**[25. Optimization III - Non-Coding Optimizations and Benchmarking](25.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 and AutoFDO), 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\u002FDataset quality, Metric evaluation.\n* **Stable Performance Measurement**: Cache behavior, Stable CPU performance, Multi-thread considerations, Operating system considerations, Program memory layout, Measurement overhead, Compiler optimizations.\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**[26. Software Design I - Basic Concepts (DRAFT)](26.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 Semantics**.\n- **Global Variables**.\n\n**[27. Software Design II - Design Patterns and Idioms (DRAFT)](27.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**[28. Binary Size](28.Binary_Size.pdf)**\n\n- **Binary Size Introduction**: \n- **Compiler and Linker Techniques**: Optimization flags, Debugging and runtime information flags, Symbol visibility, Exceptions flags, Linker flags, Link-Time Optimization (LTO), CMake support.\n- **Coding Aspects**: Function Inlining, Function Visibility, Templates, Static Storage Duration, Linkage, Polymorphic classes, Exceptions, Header Inclusion.\n- **Binary Size Tools**: `nm` and `objdump`, `Bloaty`, Executable packer.\n\n**[29. Build Time](29.Build_time.pdf)**\n\n- **Compile Time Introduction**: The importance of build time, Causes of long build time.\n- **Compiler Aspects**: Compiler flags, Optimized compiler builds.\n- **C++ Standard Version**.\n- **Precompiled Header (PCH)**.\n- **Linker Aspects**: Link-Time Optimization (LTO), Thin Link-Time Optimization (ThinLTO), Main linkers, Linker flags.\n- **Unity Build**.\n- **Tools for Reducing Build Time**: `ninja`, Compiler cache, Distributed compilation, RAM disk, `Include-What-You-Use (IWYU)`.\n- **Function Inlining**.\n- **Template**: Template metaprogramming cost, `extern` template, `constexpr` variable vs. template structure + `static` Data member, Tag dispatching, Fold expressions, C++20 concepts, `auto`, `using` type aliasing.\n- **Other Aspects**: C++20 modules, Overload resolution, other code aspects, Pointer Implementation (PIMPL), Include guard vs. `#pragma once`, Static vs. dynamic linking, Comments and formatting, External factors.\n- **Tools to Analyze Build Time**: Clang build-time analysis, `ninjatracing`, `Templight`, `Build Bench`, Visual Studio - `CompileScore`, Visual Studio - `C++ Build Insights`.\n\n## Reporting Bugs 🐛 and Contributing\n\nPlease see the [CONTRIBUTING.md](CONTRIBUTING.md) file for more information.\n\n## Where the Course has been used\n\nThe **Modern C++ Programming** course was created in 2018 and adopted by the [University of Verona](https:\u002F\u002Fwww.univr.it\u002Fen\u002Funiversity), Italy. It is taught as part of the Bachelor's and Master's degree programmes in Computer Science, for three and two years respectively. The course has also been used to train interns at NVIDIA.\n\n*Have you adopted the course, or are you interested in using it in certain contexts?* If so, please get in touch so that I can keep track of usage. I'm also willing to share the LaTeX source code (the Tyst version will be open-sourced on GitHub soon).\n\n## License\n\nThis repository is dual-licensed:\n\n* **Course Content:** All written materials, slides, and images are licensed under [Creative Commons Attribution 4.0 International (CC BY 4.0)](LICENSE-CC-BY-SA.md).\n* **Source Code:** All code examples and scripts are licensed under the [MIT License](LICENSE-MIT.md).\n\n## Author\n\n`Federico Busato`, [federico-busato.github.io](https:\u002F\u002Ffederico-busato.github.io\u002F)\n\n- 🌐 LinkedIn: [www.linkedin.com\u002Fin\u002Ffederico-busato\u002F](https:\u002F\u002Fwww.linkedin.com\u002Fin\u002Ffederico-busato\u002F)\n- 🦋 Bluesky: [fbusato.bsky.social](https:\u002F\u002Fbsky.app\u002Fprofile\u002Ffbusato.bsky.social)\n","这个项目是一个面向熟悉C和面向对象编程人员的现代C++编程课程，旨在提升学习者对C++03至C++26标准的理解与应用能力。其核心功能包括提供29个讲座、超过2000张幻灯片的内容，涵盖从基础到高级的C++语义及概念，并且持续更新以包含最新的语言特性。此外，该课程强调实践教学，通过简洁明了的代码示例来突出特定功能或问题点，同时涉及工具使用、编码规范、项目组织及代码优化等补充知识。它适合于希望深入了解C++并将其应用于实际开发中的程序员或学生使用。",2,"2026-06-11 03:34:48","high_star"]