# federico-busato/modern-cpp-programming

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/federico-busato-modern-cpp-programming).**

15,808 stars · 1,113 forks · HTML · CC-BY-SA-4.0

## Links

- GitHub: https://github.com/federico-busato/Modern-CPP-Programming
- Homepage: https://federico-busato.github.io/Modern-CPP-Programming/
- awesome-repositories: https://awesome-repositories.com/repository/federico-busato-modern-cpp-programming.md

## Topics

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

## Description

This project is a comprehensive educational resource and programming course covering C++ language semantics and features from C++03 through C++26. It provides structured tutorials and technical guides focused on modern C++ development.

The material offers specialized instruction on template metaprogramming, including the use of type traits and compile-time computations. It features detailed guides on concurrency and parallelism for multi-core execution, as well as a reference for software design applying SOLID principles and RAII. Additionally, it covers build performance optimization to reduce compilation times and binary sizes.

The content spans a broad capability surface, including software hardening, object-oriented programming, and low-level memory management. It provides guidance on using the standard library for containers, filesystem operations, and range algorithms, while also addressing monitoring and observability through profiling and static analysis.

The resource is delivered as a structured educational course and technical reference.

## Tags

### Programming Languages & Runtimes

- [C/C++ Tutorials](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/c-c-tutorials.md) — Provides a structured educational course and technical guides for learning C++ language semantics from C++03 to C++26.
- [Asynchronous Task Control](https://awesome-repositories.com/f/programming-languages-runtimes/asynchronous-task-control.md) — Implements a comprehensive guide to managing parallel tasks using futures and promises. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Unique Ownership Management](https://awesome-repositories.com/f/programming-languages-runtimes/automatic-memory-management/unique-ownership-management.md) — Provides instruction on managing resource lifecycles using unique ownership patterns to prevent memory leaks. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Expected Value Types](https://awesome-repositories.com/f/programming-languages-runtimes/block-value-returns/method-return-values/expected-value-types.md) — Teaches the use of templates to return success or error types as an alternative to exception-based error handling. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Class Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/class-definitions.md) — Covers the fundamental syntax and structure used to define C++ classes and objects. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Class Member Access](https://awesome-repositories.com/f/programming-languages-runtimes/class-member-access.md) — Covers the use of access specifiers to encapsulate internal class state and restrict member visibility. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Class Hierarchies](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-definitions/class-hierarchies.md) — Provides comprehensive guides on creating class hierarchies through inheritance to extend functionality. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Compile-Time Conditional Branching](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expressions/compile-time-conditional-branching.md) — Instructs on using if constexpr to discard template branches at compile time based on constant expressions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/07.Basic_Concepts_V.html))
- [Compile-Time Type Constraints](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-type-constraints.md) — Instructs on enforcing requirements on template arguments using Concepts to ensure compile-time compatibility. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [Concept Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-type-constraints/concept-definitions.md) — Teaches how to specify compile-time requirements that types must satisfy to be used in templates. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [SFINAE Constraints](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-type-constraints/sfinae-constraints.md) — Instruction on using SFINAE to restrict template instantiation and filter function overloads at compile time. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [Concurrent Thread Execution](https://awesome-repositories.com/f/programming-languages-runtimes/concurrent-thread-execution.md) — Guides the spawning and management of multiple execution paths using C++ thread handles. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Custom Type Traits](https://awesome-repositories.com/f/programming-languages-runtimes/custom-type-traits.md) — Teaches how to create custom boolean compile-time checks using template specialization to verify type properties. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [Entity Declaration Management](https://awesome-repositories.com/f/programming-languages-runtimes/entity-declaration-management.md) — Teaches how to separate type introductions and properties from implementations to coordinate references across translation units. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/06.Basic_Concepts_IV.html))
- [Execution Flow Control](https://awesome-repositories.com/f/programming-languages-runtimes/execution-flow-control.md) — Covers the fundamental use of conditional statements, loops, and jump instructions to direct program logic. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/06.Basic_Concepts_IV.html))
- [Fixed-Width Integer Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/fixed-width-integer-implementations.md) — Guides the use of integer types with guaranteed bit-widths for consistent data representation across different hardware architectures. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/04.Basic_Concepts_II.html))
- [Function Argument Passing](https://awesome-repositories.com/f/programming-languages-runtimes/function-argument-passing.md) — Covers the mechanisms for passing procedural logic as parameters using function pointers and function objects. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Default Arguments](https://awesome-repositories.com/f/programming-languages-runtimes/function-argument-passing/default-arguments.md) — Explains the use of optional parameters that employ predefined values when no argument is provided during a function call. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Generated Function Configuration](https://awesome-repositories.com/f/programming-languages-runtimes/generated-function-configuration.md) — Explains how to use default keywords for standard implementations of constructors, destructors, and operators. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Initialization Order Protection](https://awesome-repositories.com/f/programming-languages-runtimes/initialization-order-protection.md) — Provides strategies for ensuring global variables are initialized safely to avoid undefined behavior. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/13.Translation_Units_I.html))
- [Inline Entity Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/inline-entity-definitions.md) — Teaches how to mark functions and variables as inline to allow identical definitions across multiple translation units. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/13.Translation_Units_I.html))
- [Integer Sign Comparison](https://awesome-repositories.com/f/programming-languages-runtimes/integer-sign-comparison.md) — Provides techniques for performing safe comparisons between different integer signs to avoid logic errors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/04.Basic_Concepts_II.html))
- [Integral Type Handling](https://awesome-repositories.com/f/programming-languages-runtimes/integral-type-handling.md) — Teaches how to manage signed and unsigned integers to avoid overflow during arithmetic or bitwise operations. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/15.Code_Convention_I.html))
- [Generics & Templates](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates.md) — Covers the creation of function templates that operate generically across multiple data types. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Variadic Template Arguments](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates/variadic-template-arguments.md) — Covers the use of parameter packs and expansion to process an arbitrary number of template arguments. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [Template Specializations](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates/variadic-template-arguments/template-specializations.md) — Explains how to provide specialized implementations for templates based on specific type arguments. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions.md) — Provides comprehensive instruction on defining the structure and constraints of data types within the C++ language. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/03.Basic_Concepts_I.html))
- [Lambda Capture and Invocation Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/polymorphic-logic/generic-lambda-expressions/lambda-capture-and-invocation-patterns.md) — Covers the syntax, capture modes, and implementation of inline local functions using lambda expressions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Type Narrowing](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/type-narrowing.md) — Describes the process of converting types explicitly to acknowledge potential data loss or trigger exceptions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/07.Basic_Concepts_V.html))
- [Local Variable Captures](https://awesome-repositories.com/f/programming-languages-runtimes/local-variable-captures.md) — Explains how to bind external variables to lambdas by value or reference to maintain state. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Namespace Organization](https://awesome-repositories.com/f/programming-languages-runtimes/module-and-package-management/namespace-organization.md) — Explains how to group entities into named scopes to avoid global naming collisions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/16.Code_Convention_II.html))
- [Parallel Computing Implementation](https://awesome-repositories.com/f/programming-languages-runtimes/parallel-computing-implementation.md) — Instructs on distributing computational workloads across multiple CPU cores for increased throughput. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Optimization_III.html))
- [Lifecycle Management](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/c-c-tutorials/object-management/lifecycle-management.md) — Guides the implementation of custom copy and move logic for proper resource management. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Object Lifetime Management](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/c-c-tutorials/object-management/object-lifetime-management.md) — Explains how to determine object memory allocation and deallocation based on storage duration. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/03.Basic_Concepts_I.html))
- [Integral Promotion and Truncation](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-type-utilities/integer-conversion-utilities/integral-promotion-and-truncation.md) — Explains the rules for value movement between different integral types via truncation and promotion. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/04.Basic_Concepts_II.html))
- [Generic Function Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/functional/generic-function-definitions.md) — Provides instruction on using templates and overloading to create type-safe generic interfaces. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [C++ Programming Mastery](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/language-learning-resources/c-programming-resources/c-programming-mastery.md) — Delivers a comprehensive educational guide covering language semantics and features from C++03 through C++26.
- [RAII Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/raii-patterns.md) — Implements the RAII pattern to tie resource acquisition to object construction. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Runtime Exception Handling](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-exception-handling.md) — Instructs on using try-catch blocks and custom exception types for runtime error recovery. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Move Semantics](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/language-runtimes/move-semantics.md) — Details the mechanisms for transferring resource ownership between objects to eliminate expensive deep copies. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Safe Pointer Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/safe-pointer-type-conversions/safe-pointer-conversions.md) — Explains how to perform compile-time type checks for safe conversions between related types and pointer hierarchies. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/07.Basic_Concepts_V.html))
- [Custom Iterators](https://awesome-repositories.com/f/programming-languages-runtimes/sequence-iteration/custom-iterators.md) — Details how to implement custom traversal objects with pointer-like behavior to support range-based loops. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Iterator Trait Retrieval](https://awesome-repositories.com/f/programming-languages-runtimes/sequence-iteration/custom-iterators/iterator-trait-retrieval.md) — Explains how to extract type information and categories from iterators using traits templates. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Shared Data Synchronization](https://awesome-repositories.com/f/programming-languages-runtimes/shared-data-synchronization.md) — Details the protection of shared resources using mutexes and scope-based lock wrappers. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Type Conversion and Casting](https://awesome-repositories.com/f/programming-languages-runtimes/type-conversion-and-casting.md) — Details mechanisms for converting values between types using explicit casting to ensure type safety. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Type Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/type-conversions.md) — Covers both implicit and explicit conversions between arithmetic types using truncation and promotion rules. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/04.Basic_Concepts_II.html))
- [Virtual Table Polymorphism](https://awesome-repositories.com/f/programming-languages-runtimes/virtual-table-polymorphism.md) — Explains the implementation of dynamic dispatch using virtual method tables for polymorphism. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Assignment Operator Overloading](https://awesome-repositories.com/f/programming-languages-runtimes/assignment-operator-overloading.md) — Details how to overload assignment operators to safely handle deep copies and avoid self-assignment errors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Associative Table Management](https://awesome-repositories.com/f/programming-languages-runtimes/associative-table-management.md) — Covers the use of associative containers like maps and sets for efficient key-value data retrieval. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Automatic Type Deduction](https://awesome-repositories.com/f/programming-languages-runtimes/automatic-type-deduction.md) — Explains how the compiler automatically infers variable types to simplify declarations and enable generic programming. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Binary Size Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/binary-size-optimizations.md) — Covers techniques for reducing executable size using compiler flags and link-time optimizations. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/28.Binary_Size.html))
- [Portable C++ Subsets](https://awesome-repositories.com/f/programming-languages-runtimes/c-and-c-cross-compilation/portable-c-subsets.md) — Provides instruction on writing portable C++ code that maintains consistent behavior across different hardware targets and environments. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/16.Code_Convention_II.html))
- [Cache Locality Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/cache-locality-optimizations.md) — Provides instruction on aligning software patterns with cache locality and thread affinity to increase data access speed. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_I.html))
- [Override Enforcement](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-overrides/override-enforcement.md) — Provides instruction on using the override keyword to ensure derived class methods correctly match base signatures. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Const Correctness Enforcement](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-correctness-verification/const-correctness-enforcement.md) — Teaches the use of const and constexpr qualifiers to enforce immutability and prevent accidental object modification. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Compile-Time Assertions](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expressions/compile-time-conditional-branching/compile-time-assertions.md) — Covers the use of static assertions and constexpr to validate logic during the compilation phase. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/16.Code_Convention_II.html))
- [Compile-Time Type Inspection](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-type-inspection.md) — Explains how to check for specific members or supported operations within a structure using type traits. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [Compile-Time Type Property Queries](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-type-property-queries.md) — Classifies types by triviality, layout, and lifetime to ensure low-level copying compatibility. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/03.Basic_Concepts_I.html))
- [Compiler Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-infrastructure/compiler-optimizations.md) — Guides the use of profile-guided and link-time optimizations to improve the efficiency of compiled machine code. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Profile-Guided Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/optimization-frameworks/profile-guided-optimizations.md) — Teaches the use of runtime execution data to inform compiler optimization of frequent code paths. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Optimization_III.html))
- [Container Interface Restrictions](https://awesome-repositories.com/f/programming-languages-runtimes/container-interface-restrictions.md) — Shows how to wrap standard containers to implement restricted interfaces such as stacks and queues. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Copy Prevention Techniques](https://awesome-repositories.com/f/programming-languages-runtimes/copy-prevention-techniques.md) — Explains how to disable object copying by explicitly deleting copy constructors in C++. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Dependent Name Resolution](https://awesome-repositories.com/f/programming-languages-runtimes/dependent-name-resolution.md) — Guides the use of keywords to explicitly identify types that depend on template parameters. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [File Read and Write Operations](https://awesome-repositories.com/f/programming-languages-runtimes/file-read-and-write-operations.md) — Provides primitives for opening, seeking, and reading or writing files on the local filesystem. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Filesystem Path Handling](https://awesome-repositories.com/f/programming-languages-runtimes/filesystem-path-handling.md) — Explains how to store and decompose file paths into their constituent parts. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Forward Declaration Strategies](https://awesome-repositories.com/f/programming-languages-runtimes/forward-declaration-strategies.md) — Teaches how to use forward declarations to reduce the number of files processed by the compiler. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Forward Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/forward-declarations.md) — Instructs on the practice of declaring identifiers before their full definition to break circular dependencies. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Perfect Forwarding](https://awesome-repositories.com/f/programming-languages-runtimes/function-argument-passing/perfect-forwarding.md) — Covers the implementation of perfect forwarding to avoid unnecessary object copies during function calls. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Function Objects](https://awesome-repositories.com/f/programming-languages-runtimes/function-objects.md) — Teaches how to overload the function call operator to create invocable objects. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Value Category Overloads](https://awesome-repositories.com/f/programming-languages-runtimes/function-overloading/value-category-overloads.md) — Explains how to implement different function behaviors based on whether the calling object is an lvalue or rvalue. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Functor Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/functor-implementations.md) — Explains how to overload the function call operator to create function objects, also known as functors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Header Dependency Analysis](https://awesome-repositories.com/f/programming-languages-runtimes/header-file-inclusions/header-dependency-analysis.md) — Describes techniques for analyzing and removing redundant header inclusions to speed up compilation. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Inclusion Guards](https://awesome-repositories.com/f/programming-languages-runtimes/header-file-inclusions/inclusion-guards.md) — Teaches the use of include guards and preprocessor directives to prevent multiple header processing. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Inclusion Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/header-file-inclusions/inclusion-optimizations.md) — Provides guidance on optimizing header inclusions to minimize the number of files processed during compilation. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Precompiled Headers](https://awesome-repositories.com/f/programming-languages-runtimes/header-file-inclusions/precompiled-headers.md) — Covers the use of precompiled headers to avoid redundant parsing of heavy headers across multiple files. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Heterogeneous Containers](https://awesome-repositories.com/f/programming-languages-runtimes/heterogeneous-containers.md) — Guides the use of heterogeneous containers like std::tuple and std::variant to store multiple different types. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [I/O Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/i-o-optimizations.md) — Describes techniques for improving the performance of standard input and output streams. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/24.Optimization_II.html))
- [Symbol Visibility Controls](https://awesome-repositories.com/f/programming-languages-runtimes/language-ecosystems-tooling/module-management/module-systems/synchronous-module-loaders/module-interface-exports/symbol-visibility-controls.md) — Provides guidance on controlling symbol visibility within modules to define clean public interfaces. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Smart Pointers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/synchronization-primitives/smart-pointers.md) — Guides the use of unique and shared pointers to automate object lifetime and prevent leaks. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Class Template Argument Deductions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates/variadic-template-arguments/class-template-argument-deductions.md) — Details how C++ infers class template parameters from constructor arguments using deduction guides. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/12.Templates_II.html))
- [Fold Expressions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates/variadic-template-arguments/fold-expressions.md) — Demonstrates how to handle arbitrary function arguments using parameter packs and folding expressions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Type-Safe Variants](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-extensions/union-types/type-safe-variants.md) — Instructs on using type-safe unions, such as std::variant, to hold one of several predefined types. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Variadic Macros](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/variadic-macros.md) — Covers the definition and use of macros that accept a variable number of arguments. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Ownership Transfer](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/ownership-borrowing/ownership-transfer.md) — Instruction on moving resources between objects using move constructors to avoid deep copies. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Value Category Overloading](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/type-based-overloading/value-category-overloading.md) — Provides instruction on implementing member functions that distinguish between lvalue and rvalue objects. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Compile-Time Evaluable Lambdas](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/polymorphic-logic/generic-lambda-expressions/compile-time-evaluable-lambdas.md) — Teaches how to use constexpr lambdas to execute logic during compilation and reduce runtime overhead. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Template Constraints](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/polymorphic-logic/generic-lambda-expressions/lambda-capture-and-invocation-patterns/lambda-refactoring/template-constraints.md) — Explains the use of templates and requires clauses to enforce type safety in generic lambdas. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Implicit Narrowing Prevention](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/type-narrowing/implicit-narrowing-prevention.md) — Provides guidance on using brace initialization to block implicit conversions that would cause precision loss. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/07.Basic_Concepts_V.html))
- [Type Safety](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety.md) — Provides techniques for enforcing type safety using explicit constructors and scoped enums. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/16.Code_Convention_II.html))
- [Loop Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/loop-optimizations.md) — Covers compiler-level loop transformations including fission, fusion, and tiling to improve execution speed. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Optimization_III.html))
- [Function Inlining](https://awesome-repositories.com/f/programming-languages-runtimes/looping-constructs/function-inlining.md) — Explains how to control function inlining to optimize the trade-off between speed and binary size. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Loop Tiling and Fusion](https://awesome-repositories.com/f/programming-languages-runtimes/looping-constructs/loop-unrolling-transformations/loop-tiling-and-fusion.md) — Teaches loop reorganization techniques like fusion and tiling to improve CPU cache efficiency. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Optimization_III.html))
- [Memory Layout Structuring](https://awesome-repositories.com/f/programming-languages-runtimes/memory-layout-structuring.md) — Explains how to combine data members into structures and unions to precisely manage memory layout. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/06.Basic_Concepts_IV.html))
- [Symbol Re-exports](https://awesome-repositories.com/f/programming-languages-runtimes/module-importing/configuration-module-imports/symbol-re-exports.md) — Explains how to import symbols from one module to make them available to importers of another. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Module Partitioning](https://awesome-repositories.com/f/programming-languages-runtimes/module-partitioning.md) — Teaches how to split large modules into isolated partitions to manage visibility and export a unified interface. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Object Construction Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/object-construction-optimizations.md) — Explains copy elision to eliminate redundant copy and move operations during object creation. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Object Initializers](https://awesome-repositories.com/f/programming-languages-runtimes/object-construction-optimizations/object-initializers.md) — Covers the use of constructors and uniform initialization to establish valid initial object states. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [One Definition Rule Compliance](https://awesome-repositories.com/f/programming-languages-runtimes/one-definition-rule-compliance.md) — Teaches how to organize declarations across files to comply with the C++ One Definition Rule. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/13.Translation_Units_I.html))
- [Operator Overloading for Indexing](https://awesome-repositories.com/f/programming-languages-runtimes/operator-overloading-for-indexing.md) — Teaches how to overload the subscript operator to implement custom array-like indexing. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Preprocessor Code Generation](https://awesome-repositories.com/f/programming-languages-runtimes/preprocessor-code-generation.md) — Details the use of token-pasting and stringification for generating code during the preprocessing phase. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Concurrency and Parallelism](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/c-c-tutorials/c-core-concepts/concurrency-and-parallelism.md) — Provides specialized instruction on leveraging multi-core execution via threads, mutexes, and atomic operations.
- [Preprocessors](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/systems-languages/c/preprocessors.md) — Provides best practices for managing macros through naming prefixes and scope restrictions to minimize side effects. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/15.Code_Convention_I.html))
- [Range Algorithms](https://awesome-repositories.com/f/programming-languages-runtimes/range-algorithms.md) — Teaches how to sort, search, and transform data collections using standard range-based algorithms. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Range-Based Algorithm Execution](https://awesome-repositories.com/f/programming-languages-runtimes/range-based-algorithm-execution.md) — Explains how to execute algorithms directly on containers using range-based arguments and projections. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Range Projections](https://awesome-repositories.com/f/programming-languages-runtimes/range-projections.md) — Provides instruction on using range projections to specify comparison keys in standard library algorithms. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Range Search and Sort](https://awesome-repositories.com/f/programming-languages-runtimes/range-search-and-sort.md) — Covers standard library utilities for sorting data and performing range-based searches across various containers. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Reference Semantics](https://awesome-repositories.com/f/programming-languages-runtimes/reference-semantics.md) — Covers the management of connections between dynamic objects, including considerations for mutations and race conditions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/26.Software_Design_I.html))
- [Runtime Assertion Validation](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-assertion-validation.md) — Teaches how to use assertions and contracts to validate function preconditions and postconditions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Conditional Types](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/conditional-types.md) — Covers type-level decision systems that select between different types based on compile-time predicates. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/11.Templates_I.html))
- [Scoped Enumerations](https://awesome-repositories.com/f/programming-languages-runtimes/scoped-enumerations.md) — Provides instruction on using scoped enum classes to avoid namespace pollution and improve type safety. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/15.Code_Convention_I.html))
- [Sequential Data Management](https://awesome-repositories.com/f/programming-languages-runtimes/sequential-data-management.md) — Explains the organization of elements in linear sequences using contiguous or linked memory structures. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Source Code Modularization](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-modularization.md) — Instructs on grouping source files into independently compiled modules with explicit interface control. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Standard Input/Output Streams](https://awesome-repositories.com/f/programming-languages-runtimes/standard-input-output-streams.md) — Provides interfaces for reading from and writing to console streams using manipulators. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Static Polymorphism](https://awesome-repositories.com/f/programming-languages-runtimes/static-polymorphism.md) — Teaches the implementation of static polymorphism using template inheritance to avoid runtime virtual table overhead. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/27.Software_Design_II.html))
- [String Manipulation](https://awesome-repositories.com/f/programming-languages-runtimes/string-manipulation.md) — Covers fundamental C++ operations for searching, slicing, and modifying character sequences. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Value Semantics Management](https://awesome-repositories.com/f/programming-languages-runtimes/strong-type-definitions/value-semantics-management.md) — Instruction on choosing between value and reference semantics to manage object lifecycles and shared state. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/26.Software_Design_I.html))
- [Symbol Linkage Control](https://awesome-repositories.com/f/programming-languages-runtimes/symbol-linkage-control.md) — Explains how to control identifier visibility across translation units to prevent naming conflicts. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/13.Translation_Units_I.html))
- [Type Relationship Verification](https://awesome-repositories.com/f/programming-languages-runtimes/type-relationship-verification.md) — Determines if two types are the same, if one is a base class, or if they are convertible. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/11.Templates_I.html))
- [Type Transformations](https://awesome-repositories.com/f/programming-languages-runtimes/type-transformations.md) — Covers modifying types by adding or removing qualifiers or converting signedness at compile time. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/11.Templates_I.html))
- [Undefined Behavior Detection](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection.md) — Configures compilers to detect and force termination during null dereferences or integer overflows. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Integer Overflow Detections](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection/integer-overflow-detections.md) — Teaches methods to implement runtime checks that detect and handle integer arithmetic overflows. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/04.Basic_Concepts_II.html))
- [Memory and Concurrency Error Detection](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection/memory-and-concurrency-error-detection.md) — Guides the use of compiler-based instrumentation to identify memory errors and undefined behavior. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Variable Scope Controls](https://awesome-repositories.com/f/programming-languages-runtimes/variable-scope-controls.md) — Teaches rules for variable placement and scope management to improve memory safety. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/15.Code_Convention_I.html))
- [Zero-Copy String Views](https://awesome-repositories.com/f/programming-languages-runtimes/zero-copy-string-views.md) — Demonstrates the use of non-owning string views to avoid expensive memory allocations and copies. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))

### Development Tools & Productivity

- [Template Metaprogramming](https://awesome-repositories.com/f/development-tools-productivity/build-tooling/build-time-tooling/template-metaprogramming.md) — Offers specialized instruction on template metaprogramming for compile-time computations and type transformations.
- [Unity Builds](https://awesome-repositories.com/f/development-tools-productivity/build-performance-optimization/unity-builds.md) — Explains the Unity build technique of merging source files into larger translation units to reduce header parsing. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Compilation Flags](https://awesome-repositories.com/f/development-tools-productivity/build-tooling/build-orchestration-logic/build-orchestration-configuration/build-automation-systems/build-systems/compilation-flags.md) — Provides instruction on configuring compiler and linker flags to optimize binary performance and size. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Optimization_III.html))
- [Runtime Call-Stack Capturers](https://awesome-repositories.com/f/development-tools-productivity/call-stack-navigators/runtime-call-stack-capturers.md) — Provides guidance on capturing and interpreting runtime call stacks to diagnose program crashes. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Code Quality and Analysis](https://awesome-repositories.com/f/development-tools-productivity/code-quality-analysis.md) — Covers static analysis and linting techniques to detect bugs and enforce coding style guidelines. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Compiler Caches](https://awesome-repositories.com/f/development-tools-productivity/compiler-caches.md) — Discusses the use of compiler caches to reuse previous build outputs and accelerate development. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Instantiation Constraints](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/debugging-inspection-tools/debugging-and-inspection-tools/runtime-debugging/template-instantiation-debugging/instantiation-constraints.md) — Teaches how to suppress implicit template instantiation across translation units to minimize redundant work. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [CPU Profilers](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/performance-resource-profilers/cpu-profilers.md) — Guides users through CPU profiling to identify performance bottlenecks and analyze cache behavior. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Optimization_III.html))
- [Text String Manipulation Utilities](https://awesome-repositories.com/f/development-tools-productivity/developer-utilities-libraries/programming-logic-libraries/text-string-manipulation-utilities.md) — Provides guidance on using dynamic string wrappers for advanced text manipulation, concatenation, and conversion. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Filesystem Management](https://awesome-repositories.com/f/development-tools-productivity/directory-management/administrative-directory-managers/filesystem-directory-operations/filesystem-management.md) — Covers path manipulation, directory iteration, and file deletion operations. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Compiled Module Units](https://awesome-repositories.com/f/development-tools-productivity/extension-compilers/extension-module-compilers/compiled-module-units.md) — Explains the use of compiled module units to replace headers and improve build isolation and speed.
- [Implementation Hiding](https://awesome-repositories.com/f/development-tools-productivity/extension-compilers/extension-module-compilers/compiled-module-units/implementation-hiding.md) — Instructs on using module implementation units to hide internal definitions and accelerate build times. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Legacy Header Imports](https://awesome-repositories.com/f/development-tools-productivity/extension-compilers/extension-module-compilers/compiled-module-units/legacy-header-imports.md) — Describes how to treat traditional header files as modules to accelerate compilation without altering existing declarations. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Enumerated Constants](https://awesome-repositories.com/f/development-tools-productivity/predefined-constants/geometric-constants/enumerated-constants.md) — Instructs on organizing related integral constants into scoped enumerations to prevent implicit type conversions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/06.Basic_Concepts_IV.html))
- [Symbol Table Inspection](https://awesome-repositories.com/f/development-tools-productivity/symbol-table-inspection.md) — Explains how to inspect symbol tables in object files and executables to diagnose linking errors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Assertion-Based Validations](https://awesome-repositories.com/f/development-tools-productivity/validation-logic/logic-validation-frameworks/assertion-based-validations.md) — Teaches the use of assertions to detect and validate logic errors during the development process. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Runtime Assertions](https://awesome-repositories.com/f/development-tools-productivity/validation-logic/logic-validation-frameworks/runtime-assertions.md) — Instructs on implementing logic constraints and assertions to pinpoint runtime failures. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))

### Education & Learning Resources

- [C++ Concurrency and Parallelism Courses](https://awesome-repositories.com/f/education-learning-resources/c-concurrency-and-parallelism-courses.md) — Offers a comprehensive educational module on executing C++ code across multiple CPU cores.
- [C++ Software Design Courses](https://awesome-repositories.com/f/education-learning-resources/c-software-design-courses.md) — Provides structured tutorials on building maintainable C++ architectures using SOLID and RAII.
- [Weak Reference Wrappers](https://awesome-repositories.com/f/education-learning-resources/language-reference-guides/reference-safety/weak-reference-wrappers.md) — Instructs on using weak references to prevent circular dependencies and manage object lifecycles in shared memory. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [C++ Software Hardening Courses](https://awesome-repositories.com/f/education-learning-resources/c-software-hardening-courses.md) — Teaches diagnostic techniques and security measures to harden C++ code against memory vulnerabilities.
- [Queues](https://awesome-repositories.com/f/education-learning-resources/data-structure-implementations/queues.md) — Provides educational content on implementing First-In-First-Out queue data structures. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Stacks](https://awesome-repositories.com/f/education-learning-resources/data-structure-implementations/stacks.md) — Teaches the use of Last-In-First-Out stacks for sequential data retrieval. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Opaque Pointer Handles](https://awesome-repositories.com/f/education-learning-resources/educational-resources/languages-and-programming-concepts/programming-language-mastery-guides/object-oriented-programming-concepts/encapsulation-techniques/opaque-handles/opaque-pointer-handles.md) — Demonstrates how to hide private data behind opaque pointers to decouple interfaces from implementations.

### Operating Systems & Systems Programming

- [Integer Atomic Operations](https://awesome-repositories.com/f/operating-systems-systems-programming/lock-free-atomic-containers/integer-atomic-operations.md) — Provides detailed instruction on utilizing lock-free atomic operations for high-performance thread safety. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Atomic Thread Synchronization](https://awesome-repositories.com/f/operating-systems-systems-programming/atomic-thread-synchronization.md) — Provides detailed instructions on protecting shared memory using both mutexes and lock-free atomic operations.
- [Binary Bloat Analysis](https://awesome-repositories.com/f/operating-systems-systems-programming/binary-analysis-capabilities/binary-bloat-analysis.md) — Covers tools and techniques for analyzing compiled binaries to identify and reduce executable bloat. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/28.Binary_Size.html))
- [CPU Architecture Analysis](https://awesome-repositories.com/f/operating-systems-systems-programming/cpu-architecture-analysis.md) — Analyzes the impact of CPU instruction pipelining and memory hierarchies on C++ execution speed. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_I.html))
- [CPU Instruction Optimizations](https://awesome-repositories.com/f/operating-systems-systems-programming/cpu-instruction-optimizations.md) — Provides guidance on using SIMD and specific CPU instruction sets to optimize performance. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_I.html))
- [Type-Safe Stream I/O](https://awesome-repositories.com/f/operating-systems-systems-programming/file-i-o-management/i-o-polling/file-and-console-i-o/type-safe-stream-i-o.md) — Instructs on reading and writing data using type-safe streams that incorporate user-defined types. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Filesystem Metadata Retrievers](https://awesome-repositories.com/f/operating-systems-systems-programming/filesystem-metadata-retrievers.md) — Demonstrates how to query operating system primitives to retrieve file properties like size and existence. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Binary Memory Layouts](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/binary-memory-layouts.md) — Explains how to arrange objects in memory to maintain compatibility with binary APIs. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Shared Ownership Management](https://awesome-repositories.com/f/operating-systems-systems-programming/manual-memory-management/ownership-based-memory-management/shared-ownership-management.md) — Covers the use of reference counting to manage resources with multiple owners. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Memory-Mapped I/O](https://awesome-repositories.com/f/operating-systems-systems-programming/memory-mapped-i-o.md) — Explains how to map files directly into virtual memory to bypass system calls and increase loading speed. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Standard Output Printing](https://awesome-repositories.com/f/operating-systems-systems-programming/standard-i-o-bridges/standard-output-printing.md) — Shows how to print strings and values to the standard output stream. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Virtual Memory Mappers](https://awesome-repositories.com/f/operating-systems-systems-programming/virtual-memory-management/virtual-memory-mappers.md) — Details the correlation of files directly to virtual memory segments to bypass system calls. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/24.Optimization_II.html))

### Software Engineering & Architecture

- [Abstract Data Types](https://awesome-repositories.com/f/software-engineering-architecture/abstract-data-types.md) — Instructs on creating abstract data types to separate logical behavior from implementation. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Asynchronous Task Execution](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-models/asynchronous-task-execution.md) — Explains the execution of background functions and the retrieval of results via future handles. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [Concurrency Synchronization Primitives](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-synchronization-primitives.md) — Teaches the use of mutexes and atomic types to prevent race conditions in shared memory. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Error Management](https://awesome-repositories.com/f/software-engineering-architecture/error-handling/error-management.md) — Provides guidance on capturing and managing unexpected program states using function-level handlers and try-catch blocks. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/22.Advanced_Topics_II.html))
- [RAII Resource Management](https://awesome-repositories.com/f/software-engineering-architecture/raii-resource-management.md) — Provides comprehensive guidance on using RAII to ensure deterministic resource acquisition and cleanup.
- [Resource Acquisition and Release](https://awesome-repositories.com/f/software-engineering-architecture/resource-acquisition-and-release.md) — Demonstrates pairing resource acquisition with guaranteed release via destructors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/09.Object_Oriented_I.html))
- [Resource Lifecycle Management](https://awesome-repositories.com/f/software-engineering-architecture/resource-lifecycle-management.md) — Detailed instruction on managing resource lifecycles through RAII and custom copy/move behaviors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/27.Software_Design_II.html))
- [SOLID Principles](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/foundational-theory-and-guidance/software-architecture-principles/solid-principles.md) — Provides a comprehensive reference for applying SOLID principles to create maintainable C++ software architectures. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/26.Software_Design_I.html))
- [Software Design Principles](https://awesome-repositories.com/f/software-engineering-architecture/software-design-principles.md) — Provides a reference for applying SOLID principles, design patterns, and RAII to create maintainable C++ architectures.
- [Code Complexity Metrics](https://awesome-repositories.com/f/software-engineering-architecture/code-complexity-metrics.md) — Teaches how to calculate and interpret cyclomatic and cognitive complexity metrics to assess code maintainability. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Cyclomatic Complexity Analyzers](https://awesome-repositories.com/f/software-engineering-architecture/cyclomatic-complexity-analyzers.md) — Provides methods for evaluating software complexity by analyzing control flow branches and logical operators. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Circular Dependency Resolution](https://awesome-repositories.com/f/software-engineering-architecture/dependency-resolution-engines/circular-dependency-resolution.md) — Explains techniques for resolving circular dependencies between modules using forward declarations and architectural changes. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Relational Operator Overloading](https://awesome-repositories.com/f/software-engineering-architecture/logical-comparison-operators/decimal-comparison-operators/relational-operator-overloading.md) — Instructs on implementing custom comparison logic using relational and three-way comparison operators. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Memory Layout Optimizations](https://awesome-repositories.com/f/software-engineering-architecture/memory-layout-optimizations.md) — Teaches how to design standard-layout types for efficient operations and low-level API compatibility. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Object Instantiation Restrictions](https://awesome-repositories.com/f/software-engineering-architecture/object-instantiation-restrictions.md) — Covers techniques for restricting object instantiation, such as implementing the Singleton pattern for global access. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/27.Software_Design_II.html))
- [Operator Overloading for Comparisons](https://awesome-repositories.com/f/software-engineering-architecture/operator-overloading-for-comparisons.md) — Teaches how to overload comparison operators to define custom ordering and equality for objects. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/10.Object_Oriented_II.html))
- [Optional Value Types](https://awesome-repositories.com/f/software-engineering-architecture/optional-value-types.md) — Instruction on using std::optional to explicitly represent the presence or absence of a return value. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Performance Benchmarking](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/performance-engineering/performance-benchmarking.md) — Covers the use of stable workloads to benchmark execution metrics and evaluate code changes. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/25.Optimization_III.html))
- [Return Value Optimizations](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/performance-optimization/data-handling-throughput/zero-copy-mechanisms/return-value-optimizations.md) — Explains how the compiler eliminates redundant temporary objects during function returns via copy elision and RVO. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/21.Advanced_Topics_I.html))
- [Project Structure Organization](https://awesome-repositories.com/f/software-engineering-architecture/project-structure-organization.md) — Provides guidance on organizing C++ project layouts, specifically the separation of header and source files. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/15.Code_Convention_I.html))
- [Priority Queues](https://awesome-repositories.com/f/software-engineering-architecture/queue-implementations/priority-queues.md) — Covers the implementation and usage of priority queues to manage elements based on priority. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))
- [Directory Iterators](https://awesome-repositories.com/f/software-engineering-architecture/recursive-validation-engines/recursive-tree-traversers/file-system-traversers/recursive-directory-traversers/directory-iterators.md) — Guides users on how to traverse files and folders within a directory using the standard library. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Memory Access Pattern Optimizers](https://awesome-repositories.com/f/software-engineering-architecture/shared-memory-management/memory-access-profilers/tiled-memory-access-patterns/memory-access-pattern-optimizers.md) — Covers optimization of memory access patterns to maximize CPU cache efficiency and minimize latency. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_I.html))
- [Compile-Time Template Optimizations](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/abstraction-domain-modeling/compile-time-architectural-patterns/compile-time-template-optimizations.md) — Provides methods for reducing compile-time overhead using extern templates and fold expressions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))
- [Range-Based Sorting](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/sorted-array-searchers/range-based-sorting.md) — Instructs on executing search and sort operations across ranges using standard C++ functions. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))

### Part of an Awesome List

- [Lazy Range Views](https://awesome-repositories.com/f/awesome-lists/data/sequence-processing/lazy-range-views.md) — Teaches the implementation of composable, lazy-evaluated range views for efficient sequence transformation.
- [Compilation Performance Optimization](https://awesome-repositories.com/f/awesome-lists/devtools/build-and-compilation/compilation-performance-optimization.md) — Offers detailed technical guides on reducing compilation times and binary footprints using modern C++ tooling.
- [Filesystem Object Management](https://awesome-repositories.com/f/awesome-lists/devtools/filesystem-object-management.md) — Provides a guide to operations for creating, removing, and listing files and directories. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/modern-cpp.html))
- [Filesystem Object Modification](https://awesome-repositories.com/f/awesome-lists/devtools/filesystem-object-management/filesystem-object-modification.md) — Instructs on how to create, copy, rename, and remove files and directories on disk. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))

### Content Management & Publishing

- [Range Generation](https://awesome-repositories.com/f/content-management-publishing/q-a-content-strategies/range-generators/range-generation.md) — Explains how to produce on-the-fly sequences of elements using C++ range factories. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/20.Iterators_Containers_Alg.html))

### Data & Databases

- [Static Binary Archives](https://awesome-repositories.com/f/data-databases/archive-storage/binary-object-archiving/static-binary-archives.md) — Describes how to bundle object files into static library archives for direct linking. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/14.Translation_Units_II.html))
- [Stream Manipulators](https://awesome-repositories.com/f/data-databases/data-buffering/buffered-input-output-managers/i-o-stream-managers/stream-manipulators.md) — Teaches the use of formatted manipulators for reading and writing data with precision. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Optional Value Types](https://awesome-repositories.com/f/data-databases/null-value-representations/optional-containers/optional-value-types.md) — Provides instruction on using wrappers like std::optional to represent values that may or may not exist. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))
- [Type-Erased Value Containers](https://awesome-repositories.com/f/data-databases/variant-data-type-storage/type-erased-value-containers.md) — Instruction on using type-erased containers like std::any to store arbitrary types safely. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/19.Utilities.html))

### DevOps & Infrastructure

- [Build Configuration Management](https://awesome-repositories.com/f/devops-infrastructure/build-configuration-management.md) — Instructs on managing environment-specific build parameters and compiler options using feature flags and variables. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/18.Ecosystem.html))
- [Conditional Compilation](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/build-tooling/build-configuration-governance/platform-specific-source-resolution/conditional-compilation.md) — Explains the use of preprocessor directives to include or exclude code based on environment or compiler. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/08.Basic_Concepts_VI.html))
- [Opaque Pointers](https://awesome-repositories.com/f/devops-infrastructure/dependency-management/dependency-injection-containers/package-dependency-decoupling/interface-based-decoupling/opaque-pointers.md) — Explains how to decouple interfaces from implementations using opaque pointers to accelerate compilation and hide internal logic. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/27.Software_Design_II.html))

### Scientific & Mathematical Computing

- [Complexity Analysis](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/computational-complexity/complexity-analysis.md) — Instructs on using asymptotic analysis to evaluate the time and memory scaling of algorithms. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_I.html))

### Security & Cryptography

- [Buffer Overflow Defenses](https://awesome-repositories.com/f/security-cryptography/buffer-overflow-defenses.md) — Teaches the use of bounds-safe containers to prevent memory corruption and buffer overflow errors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Runtime Bounds Checking](https://awesome-repositories.com/f/security-cryptography/memory-bounds-checking/array-bounds-checking/runtime-bounds-checking.md) — Enforces run-time precondition checks and bounds-checking on containers to harden library calls. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Control Flow Integrity Protections](https://awesome-repositories.com/f/security-cryptography/return-oriented-programming/control-flow-integrity-protections.md) — Provides methods to protect the execution path against return-oriented and jump-oriented programming attacks. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))

### System Administration & Monitoring

- [Build Performance Profilers](https://awesome-repositories.com/f/system-administration-monitoring/performance-profiling-tools/build-performance-profilers.md) — Teaches how to profile build times and memory usage to resolve compilation bottlenecks. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/29.Build_time.html))

### Testing & Quality Assurance

- [Code Coverage Analysis](https://awesome-repositories.com/f/testing-quality-assurance/code-coverage-analysis.md) — Instructs on measuring source code execution coverage to identify untested paths in the software. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Static Analysis](https://awesome-repositories.com/f/testing-quality-assurance/code-quality-review/static-analysis.md) — Explains the use of static analysis tools to detect style violations and programming errors. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Fuzz Testing](https://awesome-repositories.com/f/testing-quality-assurance/fuzz-testing.md) — Teaches how to use fuzz testing with mutated inputs to discover edge-case crashes and vulnerabilities. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/17.Debugging.html))
- [Performance Analysis](https://awesome-repositories.com/f/testing-quality-assurance/performance-testing-analysis/performance-analysis.md) — Provides methodologies for evaluating software efficiency using throughput and latency metrics. ([source](https://federico-busato.github.io/Modern-CPP-Programming/htmls/23.Optimization_I.html))