programming-language

Home
Theory
Theory
- Introduction
- Programming-language
  Programming-language
  - Introduction
  - How-to-master-programming-language
    How-to-master-programming-language
    
    Introduction
  - Design-and-implementation
    Design-and-implementation
    
    Introduction
    
    Design
    Design
    
    Introduction
    
    Programming-language-Memory-model
    Programming-language-Memory-model
    
    Introduction
    
    Syntax
    Syntax
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
  - Expressive-power
    Expressive-power
    
    Introduction
  - Scripting-language
    Scripting-language
    
    Scripting-language
    
    Read-eval-print-loop
- Programming-language-construct
  Programming-language-construct
  - Introduction
  - Basic-Language-construct
    Basic-Language-construct
    
    Introduction
    
    Operator-expression-statement
    
    Operator
    Operator
    
    Operator-associativity
    
    Operator-precedence
  - Subroutine
    Subroutine
    
    Introduction
    
    Subroutine
    
    Parameter-and-argument
    Parameter-and-argument
    
    Parameter
    
    Argument-and-parameter
    
    Call-subroutine
    Call-subroutine
    
    Introduction
    
    Call-convention
    
    Evaluation-strategy
    Evaluation-strategy
    
    Evaluation-strategy
    
    Lazy-evaluation
    
    Function-object
    
    First-class-function
    First-class-function
    
    Introduction
    
    Variadic-function
- Organization
  Organization
  - Introduction
  - Name
  - Scope
  - Organization
  - Translation-unit
  - Name-lookup
  - Name-bind
    Name-bind
    
    Introduction
  - Organization-is-everywhere
  - Scope-resolution-operator
- Lifetime
  Lifetime
  - Program-lifecycle
  - Object-lifetime
- Type-system
  Type-system
  - Introduction
  - Type-system
    Type-system
    
    wikipedia-Type-system
    
    Duck-type
  - Type-constructor
    Type-constructor
    
    Introduction
    
    Covariance-and-contravariance
  - Type-safety
    Type-safety
    
    Introduction
  - Static-vs-dynamic-typing
    Static-vs-dynamic-typing
    
    Introduction
  - OOP-and-type-system
    OOP-and-type-system
    
    Introduction
  - Type-conversion
    Type-conversion
    
    Type-conversion
    
    Downcast-and-upcast
  - Type-relation
    Type-relation
    
    Introduction
- Reflection&&introspection
  Reflection&&introspection
  - Introduction
  - wikipedia-Reflection
    wikipedia-Reflection
    
    Introduction
  - Type-introspection
    Type-introspection
    
    Introduction
- First-class-citizen
  First-class-citizen
  - Introduction
- Pyramid-of-doom
  Pyramid-of-doom
  - Introduction
  - Safe-navigation-operator
    Safe-navigation-operator
    
    Introduction
- Programming-paradigm
  Programming-paradigm
  - Introduction
  - Programming-paradigm
  - Common
    Common
    
    Introduction
    
    Abstraction&&polymorphism
    Abstraction&&polymorphism
    
    Introduction
    
    Program-to-an-abstraction
    Program-to-an-abstraction
    
    Introduction
    
    Polymorphism
    Polymorphism
    
    Introduction
    
    Polymorphism
    
    Ad-hoc-polymorphism
    Ad-hoc-polymorphism
    
    Introduction
    
    Parametric-polymorphism
    Parametric-polymorphism
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
    
    Static-and-dynamic-polymorphism
    Static-and-dynamic-polymorphism
    
    Introduction
    
    TODO-Concept-VS-interface
    
    TODO-Method-resolution-order
    TODO-Method-resolution-order
    
    Introduction
    
    Behavior-based&&interface
    Behavior-based&&interface
    
    Introduction
    
    Code-reuse
    Code-reuse
    
    Introduction
  - OOP
    OOP
    
    Introduction
    
    Class-based-OOP
    Class-based-OOP
    
    Introduction
    
    Prototype-based-OOP
    Prototype-based-OOP
    
    Introduction
    
    Assemble
    Assemble
    
    Introduction
    
    Inheritance
    Inheritance
    
    Introduction
    
    Composition
    Composition
    
    Introduction
    
    Delegation-and-forwarding
    Delegation-and-forwarding
    
    Delegation
    
    Forwarding
    
    Composition-over-inheritance-principle
    Composition-over-inheritance-principle
    
    Introduction
    
    Mixin
    Mixin
    
    Introduction
    
    TODO-assemble-ability
    TODO-assemble-ability
    
    Introduction
    
    TODO-assemble-as-chain
    TODO-assemble-as-chain
    
    Introduction
    
    TODO-Abstraction-and-relation
    
    Subtyping-polymorphism
    Subtyping-polymorphism
    
    Introduction
    
    Is-a
    Is-a
    
    Introduction
    
    Subtyping-VS-inheritance
    Subtyping-VS-inheritance
    
    Introduction
    
    Behavioral-subtyping
    
    Dispatch
    Dispatch
    
    Introduction
    
    Design-pattern
    Design-pattern
    
    Introduction
    
    Books
    Books
    
    Introduction
    
    Goal
    Goal
    
    Introduction
    
    Principle
    Principle
    
    Introduction
    
    SOLID
    SOLID
    
    SOLID
    
    Single-Responsibility-Principle
    Single-Responsibility-Principle
    
    Introduction
    
    Open-closed-principle
    Open-closed-principle
    
    Introduction
    
    Liskov-substitution-principle
    
    Creational-pattern
    Creational-pattern
    
    Introduction
    
    Factory
    Factory
    
    Introduction
    
    Abstract-factory-pattern
    Abstract-factory-pattern
    
    Introduction
    
    Factory-method-pattern
    Factory-method-pattern
    
    Introduction
    
    Summary
    
    Singleton-pattern
    Singleton-pattern
    
    Introduction
    
    TODO-Alternative-to-Singleton
    TODO-Alternative-to-Singleton
    
    Introduction
    
    Builder-pattern
    Builder-pattern
    
    Introduction
    
    Dependency-injection
    Dependency-injection
    
    Dependency-injection
    
    Prototype
    Prototype
    
    Introduction
    
    Object-pool-pattern
    Object-pool-pattern
    
    Introduction
    
    Behavioral-pattern
    Behavioral-pattern
    
    Introduction
    
    Visitor-pattern
    Visitor-pattern
    
    Introduction
    
    Code
    Code
    
    Code
    
    Computation-on-structure
    Computation-on-structure
    
    Introduction
    
    Iterator-pattern
    Iterator-pattern
    
    Introduction
    
    Observer-pattern
    Observer-pattern
    
    Introduction
    
    Publish-subscribe-pattern
    Publish-subscribe-pattern
    
    Introduction
    
    Strategy-pattern
    Strategy-pattern
    
    Introduction
    
    State-pattern
    State-pattern
    
    State-pattern
    
    Command-pattern
    Command-pattern
    
    Introduction
    
    Interpreter-pattern
    Interpreter-pattern
    
    Introduction
    
    Chain-of-Responsibility
    Chain-of-Responsibility
    
    Introduction
    
    Structural-pattern
    Structural-pattern
    
    Decorator-pattern
    Decorator-pattern
    
    Introduction
    
    geeksforgeeks-The-Decorator-Pattern
    geeksforgeeks-The-Decorator-Pattern
    
    Introduction
    
    wikipedia-Decorator-pattern
    wikipedia-Decorator-pattern
    
    Introduction
    
    Adaptor-pattern
    Adaptor-pattern
    
    Introduction
    
    Composite-pattern
    Composite-pattern
    
    Introduction
    
    Delegation-pattern
    Delegation-pattern
    
    Introduction
    
    Facade-pattern
    Facade-pattern
    
    Introduction
    
    Bridge-pattern
    Bridge-pattern
    
    Introduction
    
    Dispose-pattern
    Dispose-pattern
    
    Introduction
    
    Fluent-API
    Fluent-API
    
    Introduction
    
    Method-cascading
    
    Method-chaining
    
    Computation-on-structure
    Computation-on-structure
    
    Introduction
    
    Separation-of-algorithm-and-structure
    Separation-of-algorithm-and-structure
    
    Introduction
    
    Summary-of-design-pattern
    
    Summary-of-OOP
    Summary-of-OOP
    
    Introduction
    
    Class-relation-hierarchy-diagram
    Class-relation-hierarchy-diagram
    
    Introduction
    
    Glossary
    Glossary
    
    Introduction
    
    Method
    
    TODO-Trait
    
    Inheritance
    
    Method-override
  - Aspect-oriented-programming
    Aspect-oriented-programming
    
    Introduction
  - Functional-programming
    Functional-programming
    
    Introduction
    
    Pure-function
    
    Higher-order-function
    Higher-order-function
    
    Introduction
    
    Fold
    
    Map-apply
    
    First-class-function
    
    Function-composition
    Function-composition
    
    Introduction
  - Event-driven-programming
    Event-driven-programming
    
    Introduction
  - Generic-programming
    Generic-programming
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
    
    Type-requirement
    Type-requirement
    
    Introduction
    
    Concept(generic-programming)
    Concept(generic-programming)
    
    Introduction
    
    Generics
    Generics
    
    Introduction
    
    Bounded-quantification
    Bounded-quantification
    
    Introduction
  - Metaprogramming
    Metaprogramming
    
    Metaprogramming
    
    Metaclass
    
    TODO-Meta-object
  - Declarative-programming
    Declarative-programming
    
    Introduction
  - Expression-oriented-programming
    Expression-oriented-programming
    
    Introduction
  - Symbolic-programming
    Symbolic-programming
    
    Introduction
  - Dataflow-programming
    Dataflow-programming
    
    Introduction
  - Comparison
    Comparison
    
    Introduction
  - Domain-specific-programming-paradigm
    Domain-specific-programming-paradigm
    
    Introduction
- Programming-model
  Programming-model
  - Introduction
- Interface-and-implementation
  Interface-and-implementation
  - Introduction
  - Interface
    Interface
    
    Introduction
    
    wikipedia-interface
    wikipedia-interface
    
    Introduction
    
    Compatibility
    Compatibility
    
    Introduction
    
    Backward-compatibility
    Backward-compatibility
    
    Introduction
    
    Binary-code-compatibility
    Binary-code-compatibility
    
    Introduction
    
    Consistent-interface
    Consistent-interface
    
    Introduction
  - Separate-interface-from-implementation
    Separate-interface-from-implementation
    
    Introduction
- Resource-management
  Resource-management
  - Introduction
  - Handle
    Handle
    
    Introduction
    
    Tombstone
    Tombstone
    
    Introduction
  - Memory-management
    Memory-management
    
    Introduction
    
    Memory-management
    
    Manual-memory-management
    Manual-memory-management
    
    Introduction
    
    Variable
    Variable
    
    Variable
    
    Static-variable
    
    Local-variable
    
    Non-local-variable
    
    Automatic-memory-management
    Automatic-memory-management
    
    Introduction
    
    Garbage-collection
    Garbage-collection
    
    Introduction
    
    Tracing-garbage-collection
    Tracing-garbage-collection
    
    Introduction
    
    Reference-counting
    Reference-counting
    
    Introduction
    
    Automatic-Reference-Counting
    
    Implement-reference-count-use-std-atomic
    Implement-reference-count-use-std-atomic
    
    Introduction
    
    paper-A-Survey-of-Garbage-Collection-Techniques
    paper-A-Survey-of-Garbage-Collection-Techniques
    
    Introduction
    
    PEEK-and-POKE
- Serialization-deserialization
  Serialization-deserialization
  - Introduction
  - Binary-parsing
- Design-by-contract
  Design-by-contract
  - Introduction
  - Invariant
    Invariant
    
    Introduction
    
    Class-invariant
    Class-invariant
    
    Introduction
  - Assertion
    Assertion
    
    Introduction
- Compile-time-and-run-time
  Compile-time-and-run-time
  - Compile-time-and-run-time
  - Runtime
- Error-handling
  Error-handling
  - Introduction
  - Exception
    Exception
    
    Introduction
  - Stack-trace
- Program-analysis
  Program-analysis
  - Program-analysis
  - Profiling
- Code-refactoring
  Code-refactoring
  - Introduction
- Concurrent-programming-language
  Concurrent-programming-language
  - Introduction
C-family
C-family
- Introduction
C++
C++
- Introduction
- C++design-principle-feature-philosophy
  C++design-principle-feature-philosophy
  - Introduction
  - Zero-overhead-principle
    Zero-overhead-principle
    
    Introduction
- What-is-new-in-C++
  What-is-new-in-C++
  - Introduction
  - Simplify
    Simplify
    
    Introduction
    
    preshing-C++Has-Become-More-Pythonicpreshing-C++Has-Become-More-Pythonic
    preshing-C++Has-Become-More-Pythonicpreshing-C++Has-Become-More-Pythonic
    
    Introduction
  - Uniform-consistent-interface-API-syntax
    Uniform-consistent-interface-API-syntax
    
    Introduction
  - C++11
    C++11
    
    Introduction
    
    Unamed-namespace
  - C++14
    C++14
    
    Introduction
    
    TransformationTrait
    TransformationTrait
    
    Introduction
  - C++17
    C++17
    
    Introduction
    
    C++17-Temporary-materialization
    C++17-Temporary-materialization
    
    Introduction
    
    C++17-Structured-binding
    C++17-Structured-binding
    
    Introduction
    
    C++17-Parallel-algorithm
    C++17-Parallel-algorithm
    
    Introduction
    
    cppreference-ExecutionPolicy
    cppreference-ExecutionPolicy
    
    Introduction
    
    C++17-inline-varaible
    C++17-inline-varaible
    
    Introduction
  - C++20
    C++20
    
    Introduction
    
    span
    span
    
    Introduction
- CppReference
  CppReference
  - Introduction
  - Basic-concept
    Basic-concept
    
    Introduction
    
    Basic-concepts
    Basic-concepts
    
    Introduction
    
    Declaration-and-definition
    Declaration-and-definition
    
    Introduction
    
    Declaration
    Declaration
    
    Introduction
    
    The-Clockwise-Spiral-Rule
    The-Clockwise-Spiral-Rule
    
    Introduction
    
    Complex-declarations
    Complex-declarations
    
    Introduction
    
    Pointer-to-function-and-function-type
    
    Definition
    Definition
    
    ODR
    
    Object
    Object
    
    Introduction
    
    cppreference-object
    cppreference-object
    
    Introduction
    
    Object-alignment-requirement
    Object-alignment-requirement
    
    Introduction
    
    Object-type-value
    Object-type-value
    
    Introduction
    
    Lifetime&&storage-duration
    Lifetime&&storage-duration
    
    Object-lifetime
    Object-lifetime
    
    Introduction
    
    Storage-duration
    Storage-duration
    
    Introduction
    
    Static-storage-duration
    Static-storage-duration
    
    Introduction
    
    pabloariasal-C++Initialization-of-Static-Variables
    pabloariasal-C++Initialization-of-Static-Variables
    
    Introduction
    
    Non-local-object
    Non-local-object
    
    Introduction
    
    Static-local-object
    Static-local-object
    
    Introduction
    
    Static-and-dynamic-initialization
    
    Idioms
    Idioms
    
    Introduction
    
    Static-Initialization-Order-Fiasco
    Static-Initialization-Order-Fiasco
    
    Introduction
    
    Construct-On-First-Use-Idiom
    Construct-On-First-Use-Idiom
    
    Introduction
    
    Nifty-Counter-idiom
    Nifty-Counter-idiom
    
    Introduction
    
    Attach-by-Initialization-idiom
    Attach-by-Initialization-idiom
    
    Introduction
    
    Paper-N2660-Magic-static
    Paper-N2660-Magic-static
    
    Introduction
    
    Thread-local-storage-duration
    Thread-local-storage-duration
    
    Introduction
    
    Access-outside-of-object-lifetime
    Access-outside-of-object-lifetime
    
    Introduction
    
    Case-example
    Case-example
    
    Introduction
    
    Multi-thread&&observer-pattern
    Multi-thread&&observer-pattern
    
    Introduction
    
    Example
    
    Pure-virtual-method-called
    Pure-virtual-method-called
    
    Introduction
    
    TODO-artima-Pure-Virtual-Function-Called-An-Explanation
    TODO-artima-Pure-Virtual-Function-Called-An-Explanation
    
    Introduction
    
    Layout
    Layout
    
    Object-layout
    
    Trivial
    
    Passive-data-structure
    
    Object-operation
    Object-operation
    
    Introduction
    
    Serialization-deserialization
    Serialization-deserialization
    
    Introduction
    
    Binary-representation
    Binary-representation
    
    Introduction
    
    Organization
    Organization
    
    Introduction
    
    Scope
    Scope
    
    Introduction
    
    Scope-resolution-operator
    
    Namespace
    Namespace
    
    Introduction
    
    Type-system
    Type-system
    
    Introduction
    
    Type-system
    Type-system
    
    Introduction
    
    OOP-class-type
    OOP-class-type
    
    Introduction
    
    Polymorphic-type
    
    Byte-type
    Byte-type
    
    Introduction
    
    Type-operation
    Type-operation
    
    Introduction
    
    Query-type
    Query-type
    
    Introduction
    
    decltype
    
    typeid
    typeid
    
    typeid
    
    Print-output-type-info
    Print-output-type-info
    
    Introduction
    
    Type-conversion
    Type-conversion
    
    Introduction
    
    cplusplus-type-conversions
    cplusplus-type-conversions
    
    Introduction
    
    Implicit-conversion
    Implicit-conversion
    
    Introduction
    
    Lvalue-to-rvalue-conversion
    Lvalue-to-rvalue-conversion
    
    Introduction
    
    Decay
    
    Explicit-conversion
    Explicit-conversion
    
    Introduction
    
    Cast-operator
    Cast-operator
    
    Introduction
    
    static_cast
    static_cast
    
    Introduction
    
    dynamic_cast
    dynamic_cast
    
    Introduction
    
    TODO-instanceof
    TODO-instanceof
    
    Introduction
    
    const_cast
    const_cast
    
    Introduction
    
    reinterpret_cast
    reinterpret_cast
    
    Introduction
    
    User-defined-conversion
    User-defined-conversion
    
    Introduction
    
    Type-conversion-and-temporary
    Type-conversion-and-temporary
    
    Introduction
    
    Type-inference&&deduction
    Type-inference&&deduction
    
    Introduction
    
    decltype
    decltype
    
    Introduction
    
    microsoft-decltype(C++)
    microsoft-decltype(C++)
    
    Introduction
    
    auto
    auto
    
    Introduction
    
    cppreference-Placeholder-type-specifiers(since-C++11)
    cppreference-Placeholder-type-specifiers(since-C++11)
    
    Introduction
    
    Type-deduction
    
    size_t-and-ptrdiff_t
    size_t-and-ptrdiff_t
    
    Introduction
    
    pvs-studio-About-size_t-and-ptrdiff_t
    pvs-studio-About-size_t-and-ptrdiff_t
    
    Introduction
    
    ptrdiff_t
    ptrdiff_t
    
    Introduction
    
    size_t
    size_t
    
    Introduction
    
    embedded-Why-size_t-matters
    
    size_t-length
    
    TODO-Type-qualifier
    TODO-Type-qualifier
    
    Introduction
    
    wikipedia-Type-qualifier
    wikipedia-Type-qualifier
    
    Introduction
    
    CV-type-qualifiers
    CV-type-qualifiers
    
    Introduction
    
    const
    const
    
    Introduction
    
    isocpp-Const-Correctness
    isocpp-Const-Correctness
    
    Introduction
    
    const-member
    
    const-compiler-error
    
    volatile
    volatile
    
    Introduction
    
    TODO-Type-length
    TODO-Type-length
    
    Introduction
    
    Abstract-machine
    Abstract-machine
    
    Introduction
    
    Memory-model
    Memory-model
    
    Introduction
    
    Transactional-memory
    Transactional-memory
    
    Introduction
    
    Execution-model
    Execution-model
    
    Introduction
    
    Reference-and-Value-Semantics
    Reference-and-Value-Semantics
    
    Introduction
    
    akrzemi1-Value-semantics
    akrzemi1-Value-semantics
    
    Introduction
    
    isocpp-faq-Reference-and-Value-Semantics
    isocpp-faq-Reference-and-Value-Semantics
    
    Introduction
    
    By-value-and-by-reference
    By-value-and-by-reference
    
    Introduction
  - Expressions
    Expressions
    
    Introduction
    
    cppreference-Expressions
    cppreference-Expressions
    
    Introduction
    
    Discarded-value-expressions
    Discarded-value-expressions
    
    Introduction
    
    Cast-to-type-void
    Cast-to-type-void
    
    Introduction
    
    Full-expression
    
    Value-categories
    Value-categories
    
    Introduction
    
    paper-stroustrup-“New”-Value-Terminology
    paper-stroustrup-“New”-Value-Terminology
    
    Introduction
    
    cppreference-Value-categories
    cppreference-Value-categories
    
    Introduction
    
    TODO-thegreenplace-Understanding-lvalues-and-rvalues
    TODO-thegreenplace-Understanding-lvalues-and-rvalues
    
    Introduction
    
    TODO-prvalues
    
    C++Order-of-evaluation
    C++Order-of-evaluation
    
    Introduction
    
    josephmansfield-C++sequenced-before-graphs
    josephmansfield-C++sequenced-before-graphs
    
    Introduction
    
    What-is-evaluation-of-expressions
    What-is-evaluation-of-expressions
    
    Introduction
    
    cppreference-Order-of-evaluation
    cppreference-Order-of-evaluation
    
    Introduction
    
    Enforce-sequencing-between-operand
    Enforce-sequencing-between-operand
    
    Introduction
    
    Operators
    Operators
    
    Introduction
    
    Common-operators
    Common-operators
    
    Comparison-operators
    
    Increment-decrement-operators
    Increment-decrement-operators
    
    Introduction
    
    Error-prone
    
    Pow-operator
    Pow-operator
    
    Introduction
    
    Conversions
    Conversions
    
    Introduction
    
    Memory-allocation
    Memory-allocation
    
    Introduction
    
    sizeof
    
    Member-access-operators
    Member-access-operators
    
    Introduction
    
    Other
    Other
    
    Ellipsis-catch-all-operator
    Ellipsis-catch-all-operator
    
    Introduction
    
    Built-in-comma-operator
    Built-in-comma-operator
    
    Introduction
    
    Operator-overloading
    Operator-overloading
    
    Introduction
    
    Operator-precedence
    Operator-precedence
    
    Introduction
    
    Literals
    Literals
    
    Literals
    
    String-literal
    
    User-defined-literals
    
    Constant-expressions
    Constant-expressions
    
    Introduction
    
    Constant-in-C++
    Constant-in-C++
    
    Introduction
    
    Constant-expressions
    Constant-expressions
    
    Introduction
    
    C++11-constexpr
    C++11-constexpr
    
    Introduction
    
    TODO-Literal-type
    TODO-Literal-type
    
    Introduction
    
    constexpr-and-const
    constexpr-and-const
    
    Introduction
    
    C++20-constexpr-vector-string
    C++20-constexpr-vector-string
    
    Introduction
    
    modernescpp-constexpr-std-vector-and-std-string-in-C++20
    modernescpp-constexpr-std-vector-and-std-string-in-C++20
    
    Introduction
    
    C++20-consteval
    C++20-consteval
    
    Introduction
  - Statements
    Statements
    
    Iteration
    Iteration
    
    Introduction
    
    For-statement
    
    C++11-Range-based-for-loop
    C++11-Range-based-for-loop
    
    Introduction
    
    stackoverflow-make-custom-type-work-with-range-based-for-loops
    stackoverflow-make-custom-type-work-with-range-based-for-loops
    
    Introduction
    
    TODO-nextptr-How-C++range-based-for-loop-works
    TODO-nextptr-How-C++range-based-for-loop-works
    
    Introduction
    
    Selection
    Selection
    
    If
    
    Constexpr-if
    
    Switch
  - Functions
    Functions
    
    Introduction
    
    Function
    Function
    
    Introduction
    
    cppreference-Function-declaration
    cppreference-Function-declaration
    
    Introduction
    
    Function-objects
    Function-objects
    
    Introduction
    
    STL-Function-object
    STL-Function-object
    
    Introduction
    
    std-function
    std-function
    
    Introduction
    
    Examples
    
    std-function-implementation
    std-function-implementation
    
    Introduction
    
    std-bind
    std-bind
    
    Introduction
    
    STL-Functor
    STL-Functor
    
    Introduction
    
    What-is-functor
    What-is-functor
    
    Introduction
    
    Function-call
    Function-call
    
    Introduction
    
    Function-overload
    Function-overload
    
    Introduction
    
    Operator-overload
    Operator-overload
    
    Introduction
    
    Examples
    Examples
    
    Introduction
    
    Overload-resolution
    Overload-resolution
    
    Introduction
    
    accu-Overload-Resolution
    accu-Overload-Resolution
    
    Introduction
    
    cppreference-Overload-resolution
    cppreference-Overload-resolution
    
    Introduction
    
    Compile-error-Ambiguous-overload
    Compile-error-Ambiguous-overload
    
    Introduction
    
    Overload-in-OOP
    Overload-in-OOP
    
    Introduction
    
    Overload-and-return-type
    Overload-and-return-type
    
    Introduction
    
    Lambda-expression
    Lambda-expression
    
    Introduction
    
    C++14-generalized-lambda-capture
    C++14-generalized-lambda-capture
    
    Introduction
    
    First-class-function
    First-class-function
    
    Introduction
    
    Member-function-as-first-class-function
    Member-function-as-first-class-function
    
    Introduction
    
    Generic-programming
    Generic-programming
    
    Introduction
    
    Callable-concept
    Callable-concept
    
    Introduction
    
    Interface
    Interface
    
    Introduction
    
    C++17-std-invoke
    C++17-std-invoke
    
    Introduction
    
    C++17-std-apply
    C++17-std-apply
    
    Introduction
    
    Function-as-template-parameter
    Function-as-template-parameter
    
    Introduction
    
    Forwarding-reference&&perfect-forwarding
    Forwarding-reference&&perfect-forwarding
    
    Introduction
    
    C++11-forwarding-reference
    C++11-forwarding-reference
    
    Introduction
    
    thegreenplace-Perfect-forwarding-and-universal-references
    thegreenplace-Perfect-forwarding-and-universal-references
    
    Introduction
    
    Perfect-forwarding-parameter
    Perfect-forwarding-parameter
    
    Introduction
    
    C++11-std-forward
    C++11-std-forward
    
    Introduction
    
    TODO-paper-The-Forwarding-Problem-Arguments
    TODO-paper-The-Forwarding-Problem-Arguments
    
    Introduction
    
    auto&&
    auto&&
    
    Introduction
    
    Generic-forwarding-function
    Generic-forwarding-function
    
    Introduction
    
    Examples
    Examples
    
    Wrapper
    
    Variadic-arguments-function
    Variadic-arguments-function
    
    Variadic-function
    
    Template-function-signature
    Template-function-signature
    
    Introduction
    
    Function-termination
    Function-termination
    
    Introduction
    
    Function-return-type
    Function-return-type
    
    Introduction
    
    C++11-Trailing-return-type
    C++11-Trailing-return-type
    
    Introduction
    
    C++11-std-result_of
    C++11-std-result_of
    
    Introduction
    
    C++14-Return-type-deduction
    C++14-Return-type-deduction
    
    Introduction
    
    我的实践-auto-return
    我的实践-auto-return
    
    Introduction
  - Reference
    Reference
    
    Introduction
    
    cppreference-Reference
    cppreference-Reference
    
    Introduction
    
    Pointer-VS-reference
    Pointer-VS-reference
    
    Introduction
    
    TODO-C++11-std-reference_wrapper
    TODO-C++11-std-reference_wrapper
    
    Introduction
    
    std-move-and-std-forward
    std-move-and-std-forward
    
    Introduction
    
    Referenceable
    Referenceable
    
    Introduction
  - Exception
    Exception
    
    Introduction
    
    Exception-specification
    Exception-specification
    
    Introduction
    
    Dynamic-exception-specification
    
    gotw-A-Pragmatic-Look-at-Exception-Specifications
    gotw-A-Pragmatic-Look-at-Exception-Specifications
    
    Introduction
    
    Function-try-block
    Function-try-block
    
    Introduction
    
    Exception-Safety
    Exception-Safety
    
    Introduction
    
    boost-Lessons-Learned-from-Specifying-Exception-Safety-for-STL
    boost-Lessons-Learned-from-Specifying-Exception-Safety-for-STL
    
    Introduction
    
    wikipedia-Exception-safety
    wikipedia-Exception-safety
    
    Introduction
    
    STL-exception-safety
    STL-exception-safety
    
    Introduction
    
    Level-of-exception-safety
    Level-of-exception-safety
    
    Introduction
    
    No-throw-guarantee
    No-throw-guarantee
    
    Introduction
    
    Strong-exception-safety
    Strong-exception-safety
    
    Introduction
    
    Exception-Safe-Function-Call
    Exception-Safe-Function-Call
    
    Introduction
    
    gotw-56-Exception-Safe-Function-Calls
    gotw-56-Exception-Safe-Function-Calls
    
    Introduction
    
    gotw-102-Exception-Safe-Function-Calls
    gotw-102-Exception-Safe-Function-Calls
    
    Introduction
    
    TODO-vishalchovatiya-C++Exception-Handling-Best-Practices-7-Things-To-Know
    TODO-vishalchovatiya-C++Exception-Handling-Best-Practices-7-Things-To-Know
    
    Introduction
    
    Stack-unwinding
    Stack-unwinding
    
    Introduction
    
    Exception-and-stack-unwinding
    Exception-and-stack-unwinding
    
    Introduction
    
    library-Error-handling
    library-Error-handling
    
    Introduction
    
    std-uncaught_exception
    std-uncaught_exception
    
    Introduction
    
    gotw-47-Uncaught-Exceptions
    gotw-47-Uncaught-Exceptions
    
    Introduction
    
    paper-N4152
    paper-N4152
    
    Introduction
  - Enum
    Enum
    
    Introduction
  - Classes
    Classes
    
    Introduction
    
    Class
    
    Member
    Member
    
    Introduction
    
    Static-member
    Static-member
    
    Introduction
    
    Non-static-member
    Non-static-member
    
    this-pointer
    this-pointer
    
    Introduction
    
    Function-member
    Function-member
    
    Introduction
    
    Data-member
    Data-member
    
    Introduction
    
    C++11-default-member-initializer
    C++11-default-member-initializer
    
    Introduction
    
    Object-lifetime
    Object-lifetime
    
    Introduction
    
    Initialization&&deinitialization-order
    Initialization&&deinitialization-order
    
    Introduction
    
    Idioms
    Idioms
    
    Base-from-Member-idiom
    Base-from-Member-idiom
    
    Introduction
    
    boost-Base-From-Member
    boost-Base-From-Member
    
    Introduction
    
    Calling-Virtual-During-Initialization-idiom
    Calling-Virtual-During-Initialization-idiom
    
    Introduction
    
    Special-member-function
    Special-member-function
    
    Introduction
    
    Common-issue
    Common-issue
    
    Introduction
    
    Require-prohibit
    Require-prohibit
    
    Introduction
    
    Virtual
    Virtual
    
    Introduction
    
    Implicitly-defined
    Implicitly-defined
    
    Introduction
    
    Trivial
    Trivial
    
    Introduction
    
    Constructor
    Constructor
    
    Introduction
    
    cppreference-Constructor
    cppreference-Constructor
    
    Introduction
    
    Member-initializer-list
    Member-initializer-list
    
    Introduction
    
    Virtual-constructor
    
    Default-constructors
    Default-constructors
    
    Introduction
    
    Copy-constructor
    Copy-constructor
    
    Introduction
    
    TODO-Use-this-in-constructor
    TODO-Use-this-in-constructor
    
    Introduction
    
    Destructor
    Destructor
    
    Introduction
    
    cppreference-Destructors
    
    Destructor-execution
    Destructor-execution
    
    Introduction
    
    Destructor-and-inheritance
    Destructor-and-inheritance
    
    Introduction
    
    Virtual-destructor
    Virtual-destructor
    
    Introduction
    
    Destructor-and-exception
    Destructor-and-exception
    
    Introduction
    
    Copy
    Copy
    
    Introduction
    
    Polymorphic-type&©&&Object-slicing
    Polymorphic-type&©&&Object-slicing
    
    Introduction
    
    Virtual-clone
    Virtual-clone
    
    Introduction
    
    More-C++Idioms-Virtual-Constructor
    More-C++Idioms-Virtual-Constructor
    
    Introduction
    
    Non-copyable
    Non-copyable
    
    Introduction
    
    C++11-Move
    C++11-Move
    
    Introduction
    
    zhihu-Rvalue-reference
    zhihu-Rvalue-reference
    
    Introduction
    
    stackoverflow-What-is-move-semantics
    stackoverflow-What-is-move-semantics
    
    Introduction
    
    paper-A-Proposal-to-Add-Move-Semantics-Support-to-the-C++Language
    paper-A-Proposal-to-Add-Move-Semantics-Support-to-the-C++Language
    
    Introduction
    
    Move-Constructor
    Move-Constructor
    
    Introduction
    
    More-C++Idioms-Move-Constructor
    More-C++Idioms-Move-Constructor
    
    Introduction
    
    std-move
    std-move
    
    Introduction
    
    warning-binding-rvalue-to-lvalue-reference
    warning-binding-rvalue-to-lvalue-reference
    
    Introduction
    
    TODO-foonathan-Guidelines-For-Rvalue-References-In-APIs
    TODO-foonathan-Guidelines-For-Rvalue-References-In-APIs
    
    Introduction
    
    Examples
    Examples
    
    Introduction
    
    Swap
    Swap
    
    Introduction
    
    drdobbs-Andrew-Koenig-Object-Swapping
    drdobbs-Andrew-Koenig-Object-Swapping
    
    Introduction
    
    Swappable-concept-and-swap-value-idiom
    Swappable-concept-and-swap-value-idiom
    
    Introduction
    
    Non-throwing-swap-idiom
    Non-throwing-swap-idiom
    
    Introduction
    
    More-C++Idioms-Non-throwing-swap
    More-C++Idioms-Non-throwing-swap
    
    Introduction
    
    std-swap
    std-swap
    
    Introduction
    
    Assign
    Assign
    
    Introduction
    
    Virtual-assignment-operator
    Virtual-assignment-operator
    
    Introduction
    
    Non-assignable
    Non-assignable
    
    Introduction
    
    TODO-Unified-assignment-operator
    TODO-Unified-assignment-operator
    
    Introduction
    
    TODO-Relocate
    TODO-Relocate
    
    Introduction
    
    paper-P1144R2-Object-relocation-in-terms-of-move-plus-destroy
    paper-P1144R2-Object-relocation-in-terms-of-move-plus-destroy
    
    Introduction
    
    User-defined-conversion
    User-defined-conversion
    
    Introduction
    
    User-defined-conversion-function
    User-defined-conversion-function
    
    Introduction
    
    Converting-constructor
    Converting-constructor
    
    Introduction
    
    operator-bool
    operator-bool
    
    Introduction
    
    Safe-Bool-idiom
    Safe-Bool-idiom
    
    Introduction
    
    artima-The-Safe-Bool-Idiom
    artima-The-Safe-Bool-Idiom
    
    Introduction
    
    C++11-Explicit-specifier
    C++11-Explicit-specifier
    
    Introduction
    
    paper-open-std-N2333
    paper-open-std-N2333
    
    Introduction
    
    C++11-traits
    C++11-traits
    
    Introduction
    
    Member-access
    Member-access
    
    Access-specifiers
    
    Subtyping-polymorphism
    Subtyping-polymorphism
    
    Introduction
    
    Inheritance
    Inheritance
    
    Introduction
    
    Derived-classes
    Derived-classes
    
    Introduction
    
    Class-hierarchy
    Class-hierarchy
    
    Introduction
    
    Multiple-inheritance
    Multiple-inheritance
    
    Introduction
    
    isocpp-Inheritance-Multiple
    isocpp-Inheritance-Multiple
    
    Introduction
    
    Virtual-inheritance
    Virtual-inheritance
    
    Introduction
    
    Super
    Super
    
    Introduction
    
    Virtual-function
    Virtual-function
    
    Introduction
    
    Override-specifier
    Override-specifier
    
    Introduction
    
    Return-Covariant-Types
    Return-Covariant-Types
    
    Introduction
    
    Pure-virtual-function&&abstract-class
    Pure-virtual-function&&abstract-class
    
    Introduction
    
    C++11-final-specifier
    C++11-final-specifier
    
    Introduction
    
    Dispatch
    Dispatch
    
    Introduction
    
    TODO-Virtual-class
    TODO-Virtual-class
    
    Introduction
    
    Interface
    Interface
    
    Introduction
    
    gotw-What's-In-a-Class-The-Interface-Principle
    gotw-What's-In-a-Class-The-Interface-Principle
    
    Introduction
    
    Empty-base-optimization
    Empty-base-optimization
    
    Introduction
    
    Specifier
    Specifier
    
    Introduction
    
    Overload-VS-override-VS-name-hiding
    Overload-VS-override-VS-name-hiding
    
    Introduction
    
    CppCoreGuidelines-Classes-and-class-hierarchies
    CppCoreGuidelines-Classes-and-class-hierarchies
    
    Introduction
    
    TODO-assign-and-operator=
    TODO-assign-and-operator=
    
    Introduction
  - Struct
    Struct
    
    offsetof
    offsetof
    
    Introduction
    
    Struct-initialization
    Struct-initialization
    
    Introduction
    
    struct-pack
    struct-pack
    
    Introduction
    
    The-Lost-Art-of-Structure-Packing
    The-Lost-Art-of-Structure-Packing
    
    Introduction
    
    wikipedia-Data-structure-alignment
    wikipedia-Data-structure-alignment
    
    Introduction
    
    Pragma-pack-macro
  - Union
    Union
    
    Introduction
    
    Union-and-type-punning
    Union-and-type-punning
    
    Introduction
    
    C++11-std-aligned_union
    C++11-std-aligned_union
    
    Introduction
  - Initialization
    Initialization
    
    Introduction
    
    Initialization&constructor&conversion
    Initialization&constructor&conversion
    
    Introduction
    
    Initialization
    
    Default-initialization
    Default-initialization
    
    Introduction
    
    C++03-Value-initialization
    C++03-Value-initialization
    
    Introduction
    
    Direct-initialization
    Direct-initialization
    
    Introduction
    
    Copy-initialization
    Copy-initialization
    
    Introduction
    
    Syntax-ambiguity-in-initialization-with-parenthese
    Syntax-ambiguity-in-initialization-with-parenthese
    
    Introduction
    
    akrzemi1-Value-initialization-with-C++
    akrzemi1-Value-initialization-with-C++
    
    Introduction
    
    C++11-List-initialization
    C++11-List-initialization
    
    Introduction
    
    cppreference-List-initialization(since-C+11)
    cppreference-List-initialization(since-C+11)
    
    Introduction
    
    Aggregate-initialization
    Aggregate-initialization
    
    Introduction
    
    Zero-initialization
    Zero-initialization
    
    Introduction
    
    Constant-initialization
    Constant-initialization
    
    Introduction
  - Template
    Template
    
    Introduction
    
    Template-parameters-and-arguments
    Template-parameters-and-arguments
    
    Introduction
    
    Template-parameters-and-template-arguments
    
    Template-template-parameter
    Template-template-parameter
    
    Introduction
    
    STL-container-as-template-parameter
    STL-container-as-template-parameter
    
    Introduction
    
    Non-type-template-parameters
    Non-type-template-parameters
    
    Introduction
    
    Template-specialization
    Template-specialization
    
    Introduction
    
    Specialization-of-template-in-different-namespace
    
    Class-template
    Class-template
    
    Class-template
    
    Member-templates
    
    Template-and-virtual
    Template-and-virtual
    
    Introduction
    
    Virtual-method-template
    Virtual-method-template
    
    Introduction
    
    rivermatrix-C++templates-with-virtual-functions
    rivermatrix-C++templates-with-virtual-functions
    
    Introduction
    
    Class-template-inheritance
    Class-template-inheritance
    
    Introduction
    
    Variadic-inheritance
    Variadic-inheritance
    
    Introduction
    
    Friend-template
    
    Function-template
    Function-template
    
    Introduction
    
    cppreference-Function-template
    cppreference-Function-template
    
    Introduction
    
    C++14-Variable-template
    C++14-Variable-template
    
    Introduction
    
    Parameter-pack
    Parameter-pack
    
    Introduction
    
    cppreference-Parameter-pack
    cppreference-Parameter-pack
    
    Introduction
    
    eli.thegreenplace-Variadic-templates-in-C++
    eli.thegreenplace-Variadic-templates-in-C++
    
    Introduction
    
    Operations
    Operations
    
    Introduction
    
    sizeof-parameter-pack
    sizeof-parameter-pack
    
    Introduction
    
    Recursive-variadic-function-template
    Recursive-variadic-function-template
    
    Introduction
    
    Recursive-variadic-class-template
    Recursive-variadic-class-template
    
    Introduction
    
    C++17-Fold-expression
    C++17-Fold-expression
    
    Introduction
    
    Variadic-template-VS-ellipsis
    Variadic-template-VS-ellipsis
    
    Introduction
    
    Compile-template
    Compile-template
    
    Introduction
    
    SFINAE
    SFINAE
    
    Introduction
    
    Deduction
    Deduction
    
    Template-argument-deduction
    Template-argument-deduction
    
    Introduction
    
    C++17-Class-template-argument-deduction(CTAD)
    C++17-Class-template-argument-deduction(CTAD)
    
    Introduction
    
    Compile-error
    
    Define-template-in-header-file
    Define-template-in-header-file
    
    Introduction
  - Assertion
    Assertion
    
    Assert
  - Alias
    Alias
    
    Introduction
    
    Type-alias
    Type-alias
    
    Introduction
    
    Template-alias
    Template-alias
    
    Introduction
    
    Type-Generator-Idiom
    Type-Generator-Idiom
    
    Introduction
  - C++11-Attribute
    C++11-Attribute
    
    Introduction
    
    Likely-and-unlikely
    Likely-and-unlikely
    
    Introduction
    
    Deprecated
    Deprecated
    
    Introduction
    
    Deprecation
    
    TODO-Fall-through
    TODO-Fall-through
    
    Introduction
    
    Unused
    Unused
    
    Introduction
  - Using
    Using
    
    Introduction
  - C++20-Coroutine
    C++20-Coroutine
    
    Introduction
    
    lewissbaker-C++Coroutine
    lewissbaker-C++Coroutine
    
    Introduction
  - C++standard-document
    C++standard-document
    
    Introduction
  - TODO-Design-C++
    TODO-Design-C++
    
    Introduction
    
    Syntax-ambiguity
    Syntax-ambiguity
    
    Introduction
    
    Data-dependency
    Data-dependency
    
    Introduction
    
    TODO-Program-order-and-memory-order
- STL
  STL
  - Introduction
  - Design&&implementation
    Design&&implementation
    
    Introduction
    
    STL-Design
    STL-Design
    
    Introduction
    
    Policy-based-design-in-STL
    Policy-based-design-in-STL
    
    Introduction
    
    STL-components
    STL-components
    
    Introduction
    
    GCC-libstdc++
    GCC-libstdc++
    
    Introduction
    
    Dynamic-memory-management
    Dynamic-memory-management
    
    Introduction
    
    20-The-bitmap_allocator
    20-The-bitmap_allocator
    
    Introduction
    
    28-Demangling
    28-Demangling
    
    Introduction
    
    LLVM-libc++
    LLVM-libc++
    
    Introduction
    
    Microsoft-STL
    Microsoft-STL
    
    Introduction
  - Guidelines
    Guidelines
    
    Introduction
    
    Range-based-algorithms
    Range-based-algorithms
    
    Introduction
    
    cpppatterns-Range-based-algorithms
    cpppatterns-Range-based-algorithms
    
    Introduction
    
    drdobbs-STL-Algorithms-Hand-Written-Loops
    drdobbs-STL-Algorithms-Hand-Written-Loops
    
    Introduction
    
    arne-mertz-algorithms-and-the-KISS-principle
    arne-mertz-algorithms-and-the-KISS-principle
    
    Introduction
  - Idiom
    Idiom
    
    Introduction
    
    Iteration
    Iteration
    
    Introduction
    
    Zip
    Zip
    
    Introduction
    
    library-CPPItertools
    library-CPPItertools
    
    Introduction
    
    std-for_each
    std-for_each
    
    Introduction
    
    Clear-and-minimize
    Clear-and-minimize
    
    Introduction
    
    Shrink-to-fit
    
    Erase_if
    Erase_if
    
    Introduction
    
    Erase-remove
    Erase-remove
    
    Introduction
    
    TODO-Erase-while-iterating
    TODO-Erase-while-iterating
    
    Introduction
    
    Range-access
    Range-access
    
    Introduction
    
    Copy-a-range-of-elements
    Copy-a-range-of-elements
    
    Introduction
    
    TODO-Filter-and-mapper
    TODO-Filter-and-mapper
    
    Introduction
    
    TODO-Custom-filter-iterator
    
    bastian.rieck-Implementing-filter-and-map
    bastian.rieck-Implementing-filter-and-map
    
    Introduction
  - Containers
    Containers
    
    Introduction
    
    Common-issue
    Common-issue
    
    Introduction
    
    Memory-management
    Memory-management
    
    Introduction
    
    Iterator-invalidation
    Iterator-invalidation
    
    Introduction
    
    Iterator-invalidation-rules
    Iterator-invalidation-rules
    
    Introduction
    
    Thread-safety
    Thread-safety
    
    Introduction
    
    Generic-container-printer
    Generic-container-printer
    
    Introduction
    
    Concept
    Concept
    
    contiguous_container-concept
    contiguous_container-concept
    
    Introduction
    
    Member-function-table
    Member-function-table
    
    Introduction
    
    Element-access
    Element-access
    
    Introduction
    
    Uniform-consistent-API
    Uniform-consistent-API
    
    Introduction
    
    C++17-std-data
    C++17-std-data
    
    Introduction
    
    C++17-std-size-std-ssize
    C++17-std-size-std-ssize
    
    Introduction
    
    std-emplace
    std-emplace
    
    Introduction
    
    Custom-emplace
    Custom-emplace
    
    Introduction
    
    std-swap
    std-swap
    
    Introduction
    
    Sequence-container
    Sequence-container
    
    Introduction
    
    std-vector
    std-vector
    
    std-vector-bool
    std-vector-bool
    
    Introduction
    
    TODO-gotw-When-Is-a-Container-Not-a-Container
    TODO-gotw-When-Is-a-Container-Not-a-Container
    
    Introduction
    
    Resize-and-reserve
    Resize-and-reserve
    
    Introduction
    
    std-vector-end
    std-vector-end
    
    Introduction
    
    std-list
    std-list
    
    Implementation
    Implementation
    
    Introduction
    
    splice-and-merge
    splice-and-merge
    
    Introduction
    
    Operation
    
    Associative-container
    Associative-container
    
    Introduction
    
    Map
    Map
    
    Introduction
    
    Custom-type-as-key
    Custom-type-as-key
    
    Introduction
    
    C-str-as-key
    
    Enum-as-key
    
    Operations
    Operations
    
    Introduction
    
    std-for_each-map
    
    TODO-Emplace
    TODO-Emplace
    
    Introduction
    
    Values-like-python-dict
    Values-like-python-dict
    
    Introduction
    
    TODO-Erase_if
    TODO-Erase_if
    
    Introduction
    
    Iteration
    Iteration
    
    Introduction
    
    In-contain
    In-contain
    
    Introduction
    
    Container-adaptors
    Container-adaptors
    
    Introduction
    
    std-priority_queue
    std-priority_queue
    
    Introduction
    
    View
    View
    
    Introduction
    
    span
    span
    
    Introduction
    
    Span-for-multiple-level-pointer
    Span-for-multiple-level-pointer
    
    Introduction
  - Iterator-library
    Iterator-library
    
    Introduction
    
    Course-northwestern-C++Iterators
    Course-northwestern-C++Iterators
    
    Introduction
    
    Operations
    Operations
    
    Introduction
    
    Iterator-to-pointer
    Iterator-to-pointer
    
    Introduction
    
    Stream-iterators
    Stream-iterators
    
    Introduction
    
    Iterator-adaptors
    Iterator-adaptors
    
    Introduction
    
    insert_iterator
    
    front_insert_iterator
    
    back_insert_iterator
    
    const_iterator
    const_iterator
    
    Introduction
    
    Custom-iterator
    Custom-iterator
    
    Introduction
  - Algorithm
    Algorithm
    
    Introduction
    
    std-copy
    std-copy
    
    std-copy
    
    std-transform
    std-transform
    
    Introduction
    
    std-max_element-min_element-minmax_element
    std-max_element-min_element-minmax_element
    
    Introduction
    
    Sum
    Sum
    
    Introduction
    
    binary-search
    binary-search
    
    Introduction
  - C++20-Range-library
    C++20-Range-library
    
    Introduction
    
    Primer
    Primer
    
    Introduction
  - String
    String
    
    Introduction
    
    Char
    Char
    
    Introduction
    
    TODO-signed-and-unsigned-char
    
    C-string
    C-string
    
    Introduction
    
    C-string-wrapper
    C-string-wrapper
    
    Introduction
    
    Memory-manipulation
    Memory-manipulation
    
    Introduction
    
    std-memset
    std-memset
    
    Introduction
    
    std-memmove
    std-memmove
    
    Introduction
    
    C++string
    C++string
    
    Introduction
    
    basic_string
    basic_string
    
    Introduction
    
    C++17-basic_string_view
    C++17-basic_string_view
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
    
    char_traits
    char_traits
    
    Introduction
    
    String-operation
    String-operation
    
    Introduction
    
    Comparision
    Comparision
    
    Introduction
    
    Toggle-case
    Toggle-case
    
    Introduction
    
    TODO-Comma-join
    TODO-Comma-join
    
    Introduction
  - IO-library
    IO-library
    
    Introduction
    
    Buffer
    Buffer
    
    Introduction
    
    Stream-operation
    Stream-operation
    
    Introduction
    
    Predefined-standard-stream-objects
    Predefined-standard-stream-objects
    
    cin
    
    String-IO
    String-IO
    
    basic_stringstream
    
    Formatted-and-unformatted-IO
    Formatted-and-unformatted-IO
    
    Introduction
  - Thread
    Thread
    
    Introduction
    
    Mutex&&lock
    Mutex&&lock
    
    C++11-std-lock
    C++11-std-lock
    
    Introduction
    
    C++17-std-scoped_lock
    C++17-std-scoped_lock
    
    Introduction
    
    Locking-strategy
    Locking-strategy
    
    Introduction
    
    Asynchronous-programming
    Asynchronous-programming
    
    Introduction
    
    std-future
    std-future
    
    Introduction
    
    std-promise-and-future
    std-promise-and-future
    
    Introduction
    
    std-promise
    std-promise
    
    Introduction
    
    Reset-rebuild-reconnect-promise-future-channel
    Reset-rebuild-reconnect-promise-future-channel
    
    Introduction
    
    std-async-and-future
    std-async-and-future
    
    Introduction
    
    std-async
    std-async
    
    Introduction
    
    As-member
    As-member
    
    Introduction
    
    TODO-std-packaged_task-and-future
    TODO-std-packaged_task-and-future
    
    Introduction
    
    TODO-joining_thread
    TODO-joining_thread
    
    Introduction
    
    TODO-read-write-lock
    TODO-read-write-lock
    
    Introduction
    
    C++11-implementation
    C++11-implementation
    
    Introduction
    
    C++20-Semaphores
    C++20-Semaphores
    
    Introduction
    
    Inter-thread-communication
    Inter-thread-communication
    
    Introduction
    
    TODO-modernescpp-Synchronization-with-Atomics
    TODO-modernescpp-Synchronization-with-Atomics
    
    Introduction
    
    TODO-modernescpp-Performance-Comparison-of-Condition-Variables-and-Atomics
    TODO-modernescpp-Performance-Comparison-of-Condition-Variables-and-Atomics
    
    Introduction
  - Atomic-operations-library
    Atomic-operations-library
    
    Introduction
  - Utility-library
    Utility-library
    
    Utility-library
    
    Language-support
    Language-support
    
    Introduction
    
    Type-support
    Type-support
    
    Introduction
    
    Type-traits
    Type-traits
    
    Constants
    Constants
    
    Introduction
    
    Relationships
    Relationships
    
    is_convertible
    
    Type-modifications
    Type-modifications
    
    Introduction
    
    Type-transformations
    Type-transformations
    
    conditional
    
    decay
    decay
    
    Introduction
    
    std-numeric_limits
    std-numeric_limits
    
    Introduction
    
    Initializer-list
    Initializer-list
    
    Introduction
    
    General-purpose
    General-purpose
    
    Introduction
    
    Common-vocabulary-types
    Common-vocabulary-types
    
    Introduction
    
    std-tuple
    std-tuple
    
    Introduction
    
    Iterate-and-apply-to-tuple
    Iterate-and-apply-to-tuple
    
    Introduction
    
    TODO-aherrmann-Unpacking-Tuples-in-C++14
    TODO-aherrmann-Unpacking-Tuples-in-C++14
    
    Introduction
    
    TODO-murrayc-Modern-C++Variadic-template-parameters-and-tuples
    TODO-murrayc-Modern-C++Variadic-template-parameters-and-tuples
    
    Introduction
    
    Tuple-to-string
    Tuple-to-string
    
    Introduction
    
    std-optional
    std-optional
    
    Introduction
    
    std-any
    std-any
    
    Introduction Introduction
    Table of contents
    
    microsoft std::any: How, when, and why
    
    bfilipek Everything You Need to Know About std::any from C++17
    
    stackoverflow When should I use std::any
    
    cppreference std::any
    
    open-std Any Library Proposal (Revision 3)
    
    Implementation
    
    fluentcpp How std::any Works
    
    stackexchange Implementation of std::any
    
    gcc/libstdc++-v3/include/std/any
    
    github thelink2012/any
    
    library-thelink2012-any
    library-thelink2012-any
    
    Introduction
    
    std-variant
    std-variant
    
    Introduction
    
    std-visit
    std-visit
    
    Introduction
    
    std-integer_sequence
    std-integer_sequence
    
    Introduction
    
    CSDN-C++14-make_index_sequence原理
    CSDN-C++14-make_index_sequence原理
    
    Introduction
    
    stackoverflow-Implementation-C++14-make_integer_sequence
    stackoverflow-Implementation-C++14-make_integer_sequence
    
    Introduction
    
    Hash
    Hash
    
    Introduction
    
    General-purpose-hash
    General-purpose-hash
    
    Introduction
  - Dynamic-memory-management
    Dynamic-memory-management
    
    Introduction
    
    Smart-pointer-library
    Smart-pointer-library
    
    Introduction
    
    std-unique_ptr
    std-unique_ptr
    
    Introduction
    
    unique_ptr-as-member
    unique_ptr-as-member
    
    Introduction
    
    Copy-constructor-for-a-class-with-unique_ptr
    Copy-constructor-for-a-class-with-unique_ptr
    
    Introduction
    
    std-shared_ptr
    std-shared_ptr
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
    
    Guide
    Guide
    
    nextptr-shared_ptr-basics-and-internals
    nextptr-shared_ptr-basics-and-internals
    
    Introduction
    
    nextptr-Using-weak_ptr-for-circular-references
    nextptr-Using-weak_ptr-for-circular-references
    
    Introduction
    
    learncpp-std-shared_ptr
    learncpp-std-shared_ptr
    
    Introduction
    
    shared_ptr-and-this
    shared_ptr-and-this
    
    Introduction
    
    std-enable_shared_from_this
    std-enable_shared_from_this
    
    Introduction
    
    shared_ptr-and-multithread
    shared_ptr-and-multithread
    
    Introduction
    
    atomic_shared_ptr
    atomic_shared_ptr
    
    Introduction
    
    Assignment-operator
    Assignment-operator
    
    Introduction
    
    std-weak_ptr
    std-weak_ptr
    
    Introduction
    
    TODO-aliasing-constructor
    TODO-aliasing-constructor
    
    Introduction
    
    auto_ptr
    
    CppCoreGuidelines-Passing-Smart-Pointers
    CppCoreGuidelines-Passing-Smart-Pointers
    
    Introduction
    
    Guideline-strong-exception-safety
    Guideline-strong-exception-safety
    
    Introduction
    
    Prefer-use-object-generator
    Prefer-use-object-generator
    
    Introduction
    
    std-make_unique
    std-make_unique
    
    Introduction
    
    Deep-copy
    Deep-copy
    
    Introduction
    
    std-make_shared
    std-make_shared
    
    Introduction
    
    Prefer-not-use-reset
    Prefer-not-use-reset
    
    Introduction
    
    Guideline-Incomplete-type
    Guideline-Incomplete-type
    
    Introduction
    
    howardhinnant-Incomplete-types-and-shared_ptr-unique_ptr
    howardhinnant-Incomplete-types-and-shared_ptr-unique_ptr
    
    Introduction
    
    Guideline-deep-copy
    Guideline-deep-copy
    
    Introduction
    
    stackexchange-DeepPtr-a-deep-copying-unique_ptr-wrapper
    stackexchange-DeepPtr-a-deep-copying-unique_ptr-wrapper
    
    Introduction
    
    Guideline-covariance
    Guideline-covariance
    
    Introduction
    
    fluentcpp-How-to-Return-a-Smart-Pointer-AND-Use-Covariance
    fluentcpp-How-to-Return-a-Smart-Pointer-AND-Use-Covariance
    
    Introduction
    
    CppCodeReviewers-Covariant-Return-Types-and-Smart-Pointers
    CppCodeReviewers-Covariant-Return-Types-and-Smart-Pointers
    
    Introduction
    
    TODO-riptutorial-Covariant-smart-pointer-result(automated-cleanup)
    
    Guideline-subtyping-polymorphism
    Guideline-subtyping-polymorphism
    
    Introduction
    
    Guideline-overhead
    Guideline-overhead
    
    Introduction
    
    Guideline-custom-deleter
    Guideline-custom-deleter
    
    Introduction
    
    TODO-swap-reset-release
    TODO-swap-reset-release
    
    Introduction
    
    TODO-pointer_cast
    
    STL-allocator
    STL-allocator
    
    Introduction
    
    Allocator-concept
    Allocator-concept
    
    Introduction
    
    std-allocator
    std-allocator
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
    
    codeproject-C++Standard-Allocator
    codeproject-C++Standard-Allocator
    
    Introduction
  - Extending-std
    Extending-std
    
    Introduction
  - Extensions
    Extensions
    
    Version-2
    Version-2
    
    Detection-idiom
    Detection-idiom
    
    Introduction
  - Localization-library
    Localization-library
    
    Introduction
    
    GBK-to-UTF8
    GBK-to-UTF8
    
    Introduction
    
    C++实现utf8和gbk编码字符串互相转换
    C++实现utf8和gbk编码字符串互相转换
    
    Introduction
- Library
  Library
  - A-list-of-open-source-Cpp-libraries
  - Boost
    Boost
    
    Introduction
    
    Boost-community
    Boost-community
    
    Community
    
    Generic-programming-technique
    Generic-programming-technique
    
    Introduction
    
    Boost-Book
    Boost-Book
    
    BoostBook
    
    Boost-Concept-Check-Library
    Boost-Concept-Check-Library
    
    Introduction
    
    Boost-Graph-Library
    Boost-Graph-Library
    
    Introduction
    
    A-Quick-Tour-of-the-Boost-Graph-Library
    
    Boost-Graph-Library-Tutorial
    Boost-Graph-Library-Tutorial
    
    Using-adjacency_list
    
    The-Boost-Graph-Interface
    The-Boost-Graph-Interface
    
    The-Boost-Graph-Interface
    
    Visitor-Concepts
    Visitor-Concepts
    
    Visitor-Concepts
    
    Algorithms
    Algorithms
    
    Named-parameters
    
    Core-Searches
    Core-Searches
    
    breadth_first_search
    
    depth_first_search
    
    Example
    Example
    
    bfs-example
    
    Implementation
    Implementation
    
    Graph-representation
    
    Boost-Property-Tree
    Boost-Property-Tree
    
    Property-Tree
    
    Boost-Circular-Buffer
    Boost-Circular-Buffer
    
    Boost-Circular-Buffer
    
    Boost-Array
    Boost-Array
    
    Introduction
    
    Boost-Range
    Boost-Range
    
    Boost-Range
    
    Boost-Algorithm-Library
    Boost-Algorithm-Library
    
    Boost-Algorithm-Library
    
    Boost-Poly-Collection
    Boost-Poly-Collection
    
    Boost-Poly-Collection
    
    Boost-Meta-programming
    Boost-Meta-programming
    
    MPL
    
    Boost-Iterator
    Boost-Iterator
    
    Introduction
    
    Boost-iterator
    
    Iterator-Concepts
    Iterator-Concepts
    
    New-Iterator-Concepts
    
    Iterator-Facade
    
    Iterator-Adaptor
    
    Boost-TypeErasure
    Boost-TypeErasure
    
    Introduction
    
    Boost-Atomic
    Boost-Atomic
    
    Introduction
    
    Boost-Beast-lib
    Boost-Beast-lib
    
    Introduction
    
    span
    span
    
    Introduction
    
    type_traits
    type_traits
    
    Introduction
    
    make_void
    make_void
    
    Introduction
    
    Boost.Intrusive
    Boost.Intrusive
    
    Introduction
  - Communication
    Communication
    
    Introduction
    
    library-libsourcey
    library-libsourcey
    
    Introduction
  - Plugin-system
  - Abseil
    Abseil
    
    Abseil
  - Log
    Log
    
    Introduction
    
    Lightweight-logger
    Lightweight-logger
    
    Introduction
    
    stackoverflow-A-better-LOG-macro-using-template-metaprogramming
    stackoverflow-A-better-LOG-macro-using-template-metaprogramming
    
    Introduction
    
    Bartek-Improving-Print-Logging-with-Line-Pos-Info-&-Modern-C++
    Bartek-Improving-Print-Logging-with-Line-Pos-Info-&-Modern-C++
    
    Introduction
    
    Spdlog
    Spdlog
    
    Introduction
    
    Asynchronous-logging
    Asynchronous-logging
    
    Introduction
    
    Read-code
    Read-code
    
    Introduction
    
    mpmc_blocking_q
    mpmc_blocking_q
    
    Introduction
    
    thread_pool
    thread_pool
    
    Introduction
    
    我的实践
    我的实践
    
    Introduction
    
    SergiusTheBest-plog
    SergiusTheBest-plog
    
    Introduction
  - fmt
    fmt
    
    Introduction
  - Math-library
    Math-library
    
    wikipedia-List-of-numerical-libraries
    wikipedia-List-of-numerical-libraries
    
    Introduction
    
    Linear-algebra
    Linear-algebra
    
    C++linear-algebra
    
    Eigen
    
    Blaze
    Blaze
    
    Introduction
  - Partow
    Partow
    
    Introduction
    
    Strtk
    Strtk
    
    Introduction
    
    Strtk-implementation
    
    exprtk
    exprtk
    
    Introduction
  - Configuration
    Configuration
    
    Introduction
    
    XML
    XML
    
    Introduction
    
    Mazrog-srlzio
    Mazrog-srlzio
    
    Introduction
    
    Read-code
    Read-code
    
    Introduction
    
    Structure-grammar
    Structure-grammar
    
    Introduction
    
    Parsing
    Parsing
    
    Introduction
    
    Rapidxml
    Rapidxml
    
    Introduction
    
    Read-code
    Read-code
    
    Introduction
    
    zeux-pugixml
    zeux-pugixml
    
    Introduction
    
    Read-code
    Read-code
    
    Introduction
    
    Json
    Json
    
    Introduction
    
    nlohmann-json
    nlohmann-json
    
    Introduction
    
    Ini
    Ini
    
    Introduction
  - Unit-testing
    Unit-testing
    
    Introduction
    
    Googletest
    Googletest
    
    Introduction
    
    Primer
    Primer
    
    Introduction
    
    GoogleMock
    GoogleMock
    
    Introduction
    
    google-test-code-coverage
    google-test-code-coverage
    
    Introduction
    
    catchorg-Catch2
    catchorg-Catch2
    
    Introduction
    
    CSDN-catch2一个好用的C++单元测试框架
    CSDN-catch2一个好用的C++单元测试框架
    
    Introduction
  - idealvin-co
    idealvin-co
    
    Introduction
  - chromium
    chromium
    
    Introduction
    
    doc
    doc
    
    Introduction
    
    Read-code
    Read-code
    
    Introduction
    
    atomic
    atomic
    
    Introduction
  - macmade
    macmade
    
    Library-CPP-ARC
    Library-CPP-ARC
    
    Introduction
    
    Library-CPPTraits
    Library-CPPTraits
    
    Introduction
    
    Library-CrashGuard
    Library-CrashGuard
    
    Introduction
    
    Library-PIMPL
    Library-PIMPL
    
    Introduction
  - Folly
    Folly
    
    Introduction
    
    io-async
    io-async
    
    Introduction
  - Serialization&&deserialization
    Serialization&&deserialization
    
    Introduction
    
    library-USCiLab-cereal
    library-USCiLab-cereal
    
    Introduction
    
    Google-Protobuf
    Google-Protobuf
    
    Introduction
  - Command-line
    Command-line
    
    Introduction
  - GUI
    GUI
    
    Introduction
    
    QT
    QT
    
    Introduction
    
    QT-code-generator
    QT-code-generator
    
    Introduction
- Programming-paradigm
  Programming-paradigm
  - Introduction
  - OOP
    OOP
    
    Introduction
  - Generic-programming
    Generic-programming
    
    Introduction
    
    Template-is-behavior-based
    Template-is-behavior-based
    
    Introduction
    
    drdobbs-Templates-and-Duck-Typing
    drdobbs-Templates-and-Duck-Typing
    
    Introduction
    
    Concepts
    Concepts
    
    Introduction
    
    stroustrup-paper-Concepts-The-Future-of-Generic-Programming
    stroustrup-paper-Concepts-The-Future-of-Generic-Programming
    
    Introduction
    
    Named-requirements
    Named-requirements
    
    Introduction
    
    Pre-C++20-concept
    Pre-C++20-concept
    
    Introduction
    
    ConceptC++
    
    Detection-idiom
    Detection-idiom
    
    Introduction
    
    More-C++Idioms-Member-Detector
    More-C++Idioms-Member-Detector
    
    Introduction
    
    Detect-member-function
    Detect-member-function
    
    TODO-Check-if-a-class-has-a-member-function-of-a-given-signature
    TODO-Check-if-a-class-has-a-member-function-of-a-given-signature
    
    Introduction
    
    TODO-Templated-check-for-the-existence-of-a-member-function
    TODO-Templated-check-for-the-existence-of-a-member-function
    
    Introduction
    
    Detect-whether-a-type-is-defined
    Detect-whether-a-type-is-defined
    
    Introduction
    
    TODO-Raymond-Detecting in C++whether-a-type-is-defined
    TODO-Raymond-Detecting in C++whether-a-type-is-defined
    
    Introduction
    
    tartanllama-Detection-Idiom-A-Stopgap-for-Concepts
    tartanllama-Detection-Idiom-A-Stopgap-for-Concepts
    
    Introduction
    
    Ben-C++Detection-Idiom-Through-the-Years
    Ben-C++Detection-Idiom-Through-the-Years
    
    Introduction
    
    Control-ambiguity-SFINAE-fallback
    Control-ambiguity-SFINAE-fallback
    
    Introduction
    
    std-declval
    std-declval
    
    Introduction
    
    static_assert
    static_assert
    
    Introduction
    
    C++20-concept
    C++20-concept
    
    Introduction
    
    C++20-Concepts-library
    C++20-Concepts-library
    
    Introduction
    
    Regular-type
    Regular-type
    
    Introduction
    
    std-regular
    std-regular
    
    Introduction
    
    Custom-static-polymorphism-idioms
    Custom-static-polymorphism-idioms
    
    Introduction
    
    Trait
    Trait
    
    Introduction
    
    Example
    
    Type-Trait
    Type-Trait
    
    Introduction
    
    Type-traits-vs-concepts
    
    Function-trait
    Function-trait
    
    Introduction
    
    SFINAE-based
    SFINAE-based
    
    Introduction
    
    SFINAE-based-custom-polymorphism-precondition
    SFINAE-based-custom-polymorphism-precondition
    
    Introduction
    
    Helper-functions
    Helper-functions
    
    Introduction
    
    std-enable_if
    std-enable_if
    
    Introduction
    
    boost-enable_if
    boost-enable_if
    
    Introduction
    
    thegreenplace-SFINAE-and-enable_if
    thegreenplace-SFINAE-and-enable_if
    
    Introduction
    
    C++17-std-void_t
    C++17-std-void_t
    
    void_t
    
    Class-template-SFINAE
    Class-template-SFINAE
    
    Introduction
    
    Function-template-SFINAE
    Function-template-SFINAE
    
    Introduction
    
    Expression-SFINAE
    Expression-SFINAE
    
    Introduction
    
    Tag-Dispatching
    Tag-Dispatching
    
    Introduction
    
    C++17-Constexpr-if
    C++17-Constexpr-if
    
    Introduction
    
    TODO-bfilipek-Simplify-code-with-if-constexpr-in-C++17
    TODO-bfilipek-Simplify-code-with-if-constexpr-in-C++17
    
    Introduction
    
    Dispatch-based-on-constant
    Dispatch-based-on-constant
    
    Introduction
  - TMP
    TMP
    
    Introduction
    
    TMP-and-FP
    TMP-and-FP
    
    Introduction
  - AOP
    AOP
    
    Introduction
    
    Execute-Around-Pointer-idiom
    Execute-Around-Pointer-idiom
    
    Introduction
    
    AspectC++
    AspectC++
    
    Introduction
    
    accu-AOP+CRTP
    accu-AOP+CRTP
    
    Introduction
    
    cpp11_template_alias
    cpp11_template_alias
    
    Introduction
    
    my-library-Timeit
    my-library-Timeit
    
    Introduction
    
    TODO-vitiy-C++11-functional-decomposition–easy-way-to-do-AOP
    TODO-vitiy-C++11-functional-decomposition–easy-way-to-do-AOP
    
    Introduction
  - FP
    FP
    
    Introduction
  - Polymorphism
    Polymorphism
    
    Introduction
    
    Classification
    Classification
    
    Introduction
    
    External-and-Internal-Polymorphism
    External-and-Internal-Polymorphism
    
    Introduction
    
    TODO-Static-and-dynamic-polymorphism
    TODO-Static-and-dynamic-polymorphism
    
    Introduction
    
    Built-in-internal-polymorphism
    Built-in-internal-polymorphism
    
    Introduction
    
    Specialization-and-overload
    Specialization-and-overload
    
    Introduction
    
    Specialization-and-subclass-inheritance
    Specialization-and-subclass-inheritance
    
    Introduction
    
    Custom-polymorphism
    Custom-polymorphism
    
    Introduction
    
    Signature-Based-polymorphism
    Signature-Based-polymorphism
    
    Introduction
    
    wiki.c2-External-Polymorphism
    wiki.c2-External-Polymorphism
    
    Introduction
    
    Generic-function-pattern
    Generic-function-pattern
    
    Introduction
    
    Assemble-and-multiple-dispatch
    Assemble-and-multiple-dispatch
    
    Introduction
    
    Polymorphic-object-container
    Polymorphic-object-container
    
    Introduction
    
    Polymorphic-containers-with-value-semantic
    Polymorphic-containers-with-value-semantic
    
    Introduction
  - Polymorphic-value-type
    Polymorphic-value-type
    
    Introduction
    
    Type-Erasure
    Type-Erasure
    
    Introduction
    
    sodocumentation-C++type-erasure
    sodocumentation-C++type-erasure
    
    Introduction
    
    stackoverflow-Type-erasure-techniques
    stackoverflow-Type-erasure-techniques
    
    Introduction
    
    Custom-virtual-function-table
    Custom-virtual-function-table
    
    Introduction
    
    Small-object-buffer-optimization
    Small-object-buffer-optimization
    
    Introduction
    
    More-C++Idioms-Type-Erasure
    More-C++Idioms-Type-Erasure
    
    Introduction
    
    TODO-akrzemi1-Type-erasure
    TODO-akrzemi1-Type-erasure
    
    Introduction
    
    Polymorphic-Value-Types-idiom
    Polymorphic-Value-Types-idiom
    
    Introduction
    
    open-std-paper-A-polymorphic-value-type-for-C++
    open-std-paper-A-polymorphic-value-type-for-C++
    
    Introduction
    
    library-jbcoe-polymorphic_value
    library-jbcoe-polymorphic_value
    
    Introduction
    
    TODO-artima-On-the-Tension-Between-OOP-and-GP-in-C++
    TODO-artima-On-the-Tension-Between-OOP-and-GP-in-C++
    
    Introduction
    
    TODO-programmer-C++value-polymorphism-between-traditional-polymorphism-and-type-erasure
    TODO-programmer-C++value-polymorphism-between-traditional-polymorphism-and-type-erasure
    
    Introduction
    
    TODO-stackexchange-Polymorphic(owned)-reference-wrapper-for-class-hierarchies
    TODO-stackexchange-Polymorphic(owned)-reference-wrapper-for-class-hierarchies
    
    Introduction
  - Polymorphic-value-type-OOP-GP
    Polymorphic-value-type-OOP-GP
    
    Introduction
    
    ixodoi.expertscolumn-C++ Programming-void-pointer-VS-template
    ixodoi.expertscolumn-C++ Programming-void-pointer-VS-template
    
    Introduction
- Idiom
  Idiom
  - Introduction
  - OOP
    OOP
    
    Introduction
    
    Named-Constructor-idiom
    Named-Constructor-idiom
    
    Introduction
    
    Named-Parameter
    Named-Parameter
    
    Introduction
    
    Requiring-or-Prohibiting-Heap-based-Objects-idiom
    Requiring-or-Prohibiting-Heap-based-Objects-idiom
    
    Introduction
    
    Temporary-Proxy
    Temporary-Proxy
    
    Introduction
    
    Address-of-idiom
    Address-of-idiom
    
    Introduction
    
    Pointer-to-implementation-PImpl
    Pointer-to-implementation-PImpl
    
    Introduction
    
    GotW-24-Compilation-Firewalls
    GotW-24-Compilation-Firewalls
    
    Introduction
    
    GotW-100-Compilation-Firewalls
    GotW-100-Compilation-Firewalls
    
    Introduction
    
    TODO-GotW-101-Compilation-Firewalls-Part-2
    TODO-GotW-101-Compilation-Firewalls-Part-2
    
    Introduction
    
    cppreference-PImpl
    cppreference-PImpl
    
    Introduction
    
    Custom-input-output-operator
    Custom-input-output-operator
    
    Virtual-Friend-Function-Idiom
    Virtual-Friend-Function-Idiom
    
    Introduction
    
    Overload-input-output-operator
    
    MSVC-错误C2678-没有找到接受std-ostream类型的左操作数的运算符
    MSVC-错误C2678-没有找到接受std-ostream类型的左操作数的运算符
    
    Introduction
    
    TODO-Attorney-Client
    TODO-Attorney-Client
    
    Attorney-Client
    
    TODO-Temporary-Base-Class
    TODO-Temporary-Base-Class
    
    Introduction
  - Generic-programming
    Generic-programming
    
    Introduction
    
    Policy-based-design
    Policy-based-design
    
    Introduction
    
    CRTP
    CRTP
    
    Introduction
    
    thegreenplace-CRTP-in-C++
    thegreenplace-CRTP-in-C++
    
    Introduction
    
    Variadic-CRTP
    Variadic-CRTP
    
    Introduction
    
    Derived-class-template-CRTP
    Derived-class-template-CRTP
    
    Introduction
    
    Expression-Template
    Expression-Template
    
    Introduction
    
    Recursive-Type-Composition
    Recursive-Type-Composition
    
    Introduction
    
    Metafunction
    Metafunction
    
    Introduction
    
    Object-Generator
    Object-Generator
    
    Introduction
    
    Return-Type-Resolver
    Return-Type-Resolver
    
    Introduction
    
    Coercion-by-Member-Template
    Coercion-by-Member-Template
    
    Introduction
    
    TODO-Barton–Nackman-trick
    TODO-Barton–Nackman-trick
    
    Introduction
  - Object-based-resource-management
    Object-based-resource-management
    
    Introduction
    
    Copyable-and-movable
    Copyable-and-movable
    
    Introduction
    
    RAII
    RAII
    
    Introduction
    
    Essential-C++
    
    Rule-of-zero-three-five
    Rule-of-zero-three-five
    
    Introduction
    
    feabhas-Rule-of-Three-and-a-half
    feabhas-Rule-of-Three-and-a-half
    
    Introduction
    
    feabhas-Rule-of-Four-and-a-half
    feabhas-Rule-of-Four-and-a-half
    
    Introduction
    
    feabhas-Rule-of-Zero
    feabhas-Rule-of-Zero
    
    Introduction
    
    florianwolters-The-Rule-of-Zero
    florianwolters-The-Rule-of-Zero
    
    Introduction
    
    drdobbs-C++Made-Easier-The-Rule-of-Three
    drdobbs-C++Made-Easier-The-Rule-of-Three
    
    Introduction
    
    cppreference-Rule-of-three-five-zero
    cppreference-Rule-of-three-five-zero
    
    Introduction
    
    Rule-of-Zero
    Rule-of-Zero
    
    Introduction
    
    Examples
    Examples
    
    Introduction
    
    Copy-and-swap-idiom
    Copy-and-swap-idiom
    
    Introduction
    
    Scope-guard
    Scope-guard
    
    Introduction
    
    drdobbs-Generic-Change-the-Way-You-Write-Exception-Safe-Code
    drdobbs-Generic-Change-the-Way-You-Write-Exception-Safe-Code
    
    Introduction
    
    C++and-Beyond2012-Systematic-Error-Handling-in-C++
    C++and-Beyond2012-Systematic-Error-Handling-in-C++
    
    Introduction
    
    CppCon2015-Declarative-Control-Flow
    CppCon2015-Declarative-Control-Flow
    
    Introduction
    
    Implementation
    Implementation
    
    SergiusTheBest-ScopeExit
    SergiusTheBest-ScopeExit
    
    Introduction
    
    Neargye-ScopExit
    Neargye-ScopExit
    
    Introduction
    
    ricab-scope_guard
    ricab-scope_guard
    
    Introduction
    
    boost-ScopeExit
    boost-ScopeExit
    
    Introduction
    
    evgeny-panasyuk-stack_unwinding
    evgeny-panasyuk-stack_unwinding
    
    Introduction
    
    Transaction
    Transaction
    
    Introduction
    
    Resource-return
    Resource-return
    
    Introduction
    
    Returning-unique_ptr-from-functions
    Returning-unique_ptr-from-functions
    
    Introduction
  - Error-handling
    Error-handling
    
    Introduction
    
    Polymorphic-Exception
    Polymorphic-Exception
    
    Introduction
    
    Construction-Tracker
    Construction-Tracker
    
    Introduction
  - gertrudandcope-C++Idioms
    gertrudandcope-C++Idioms
    
    Introduction
    
    Handle-body-based
    Handle-body-based
    
    Introduction
    
    Handle-Body
    Handle-Body
    
    Introduction
    
    TODO-Counted-Body
    TODO-Counted-Body
    
    Introduction
- Design-pattern
  Design-pattern
  - Introduction
  - Singleton
    Singleton
    
    Introduction
    
    Singleton-mixin
    Singleton-mixin
    
    Introduction
    
    Avoid-singletons
    Avoid-singletons
    
    Introduction
    
    aristeia-paper-Perils-of-Double-Checked-Lock
    aristeia-paper-Perils-of-Double-Checked-Lock
    
    Introduction
    
    Global-VS-singleton
    Global-VS-singleton
    
    Introduction
  - Factory
    Factory
    
    Introduction
    
    Factory-mixin
  - Visitor-pattern
    Visitor-pattern
    
    Introduction
    
    thegreenplace-A-polyglot's-guide-to-multiple-dispatch
    thegreenplace-A-polyglot's-guide-to-multiple-dispatch
    
    Introduction
    
    TODO-gieseanw-Stop-reimplementing-the-virtual-table-and-start-using-double-dispatch
    TODO-gieseanw-Stop-reimplementing-the-virtual-table-and-start-using-double-dispatch
    
    Introduction
  - Decorator
    Decorator
    
    Introduction
  - Adaptor-pattern
    Adaptor-pattern
    
    Introduction
    
    Adaptor-external-polymorphism-pattern
    Adaptor-external-polymorphism-pattern
    
    Introduction
    
    TODO-paper-vanderbilt.edu-External-Polymorphism
    TODO-paper-vanderbilt.edu-External-Polymorphism
    
    Introduction
  - Mixin
    Mixin
    
    Introduction
    
    fluentcpp-Mixin-Classes-The-Yang-of-the-CRTP
    fluentcpp-Mixin-Classes-The-Yang-of-the-CRTP
    
    Introduction
    
    Parameterized-Base-Class
    Parameterized-Base-Class
    
    Introduction
    
    Variadic-mixin
    Variadic-mixin
    
    Introduction
  - Assemble-as-chain
    Assemble-as-chain
    
    Introduction
  - Design-by-contract
    Design-by-contract
    
    Introduction
    
    TODO-p0380r1-the contract proposal
    TODO-p0380r1-the contract proposal
    
    Introduction
- Resource-management
  Resource-management
  - Introduction
  - Guide
    Guide
    
    Introduction
    
    Resource-ownership
    Resource-ownership
    
    Introduction
    
    Object-based-resource-management
    Object-based-resource-management
    
    Introduction
    
    CppCoreGuidelines-Resource-Management
    CppCoreGuidelines-Resource-Management
    
    Introduction
  - Memory-management
    Memory-management
    
    Introduction
    
    Dynamic-allocation
    Dynamic-allocation
    
    Introduction
    
    malloc
    malloc
    
    Introduction
    
    Thread-safety-Reentrancy
    Thread-safety-Reentrancy
    
    Introduction
    
    realloc
    realloc
    
    Introduction
    
    new-operator
    new-operator
    
    Introduction
    
    Placement-new
    Placement-new
    
    Introduction
    
    operator-new-operator-new[]
    operator-new-operator-new[]
    
    Introduction
    
    Thread-safety-Reentrancy
    Thread-safety-Reentrancy
    
    Introduction
    
    delete-operator
    delete-operator
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
    
    Boundary-tag
    Boundary-tag
    
    Introduction
    
    Arena
    Arena
    
    Introduction
    
    Free-store
    Free-store
    
    Introduction
    
    Free-list
    Free-list
    
    Introduction
    
    Buddy-allocation
    Buddy-allocation
    
    Introduction
    
    Slab-allocation
    Slab-allocation
    
    Introduction
    
    library-jemalloc
    library-jemalloc
    
    Introduction
    
    paper
    paper
    
    Introduction
    
    library-tcmalloc
    library-tcmalloc
    
    Introduction
    
    Design
    Design
    
    Introduction
    
    C-VS-C++
    C-VS-C++
    
    Introduction
    
    Allocate-aligned-memory
    Allocate-aligned-memory
    
    Introduction
    
    Allocate-aligned-memory-manually
    Allocate-aligned-memory-manually
    
    Introduction
    
    POSIX-allocate-aligned-memory
    POSIX-allocate-aligned-memory
    
    Introduction
    
    Align-to-cacheline-word
    Align-to-cacheline-word
    
    Introduction
    
    Memory-access
    Memory-access
    
    Introduction
    
    Pointer&&array
    Pointer&&array
    
    Introduction
    
    Pointer
    Pointer
    
    Introduction
    
    Pointer
    Pointer
    
    Introduction
    
    Pointer-to-void
    Pointer-to-void
    
    Introduction
    
    thegreenplace-void-pointer-and-casts-in-C-and-C++
    thegreenplace-void-pointer-and-casts-in-C-and-C++
    
    Introduction
    
    Multiple-level-pointer
    Multiple-level-pointer
    
    Introduction
    
    Pointer-and-integer
    Pointer-and-integer
    
    Introduction
    
    uintptr_t-and-intptr_t
    uintptr_t-and-intptr_t
    
    Introduction
    
    Conversion
    
    Pointer-length
    Pointer-length
    
    Introduction
    
    Pointer-to-member
    Pointer-to-member
    
    Introduction
    
    Pointer-to-member-function
    Pointer-to-member-function
    
    Introduction
    
    Trait
    Trait
    
    Introduction
    
    Null-pointer
    Null-pointer
    
    Introduction
    
    NULL-'0'-0-nullptr
    NULL-'0'-0-nullptr
    
    Introduction
    
    nullptr-idiom
    nullptr-idiom
    
    Introduction
    
    Array
    Array
    
    Introduction
    
    stackoverflow-How-do-I-use-array-in-C++
    stackoverflow-How-do-I-use-array-in-C++
    
    Introduction
    
    cppreference-Array-declaration
    
    Array-initialization
    Array-initialization
    
    Introduction
    
    Array-in-template
    Array-in-template
    
    Introduction
    
    Create-array
    Create-array
    
    Introduction
    
    Variable-length-automatic-stack-array
    Variable-length-automatic-stack-array
    
    Introduction
    
    Multidimensional-array
    Multidimensional-array
    
    Introduction
    
    TODO-Dynamic-multiple-dimension-array
    TODO-Dynamic-multiple-dimension-array
    
    Introduction
    
    Array-length
    Array-length
    
    Introduction
    
    Array-index
    Array-index
    
    Introduction
    
    std-array
    std-array
    
    Introduction
    
    std-make_array
    std-make_array
    
    Introduction
    
    Alignment
    Alignment
    
    Introduction
    
    C++11-alignof-operator
    C++11-alignof-operator
    
    Introduction
    
    C++11-std-alignment_of
    C++11-std-alignment_of
    
    Introduction
    
    C++11-std-max_align_t
    C++11-std-max_align_t
    
    Introduction
    
    C++11-alignas-specifier
    C++11-alignas-specifier
    
    Introduction
    
    C++11-std-align
    C++11-std-align
    
    Introduction
    
    C++11-std-aligned_storage
    C++11-std-aligned_storage
    
    Introduction
    
    library-aguinet-intmem
    library-aguinet-intmem
    
    Introduction
    
    Memory-error
    Memory-error
    
    Introduction
    
    Memory-safety
    Memory-safety
    
    Introduction
    
    Segmentation-fault
    Segmentation-fault
    
    Introduction
    
    Identify-what's-causing-segmentation-faults-(segfaults)
    
    TODO-SEGFAULT-and-alignment
    TODO-SEGFAULT-and-alignment
    
    Introduction
    
    __strcpy_sse2_unaligned
    __strcpy_sse2_unaligned
    
    Introduction
    
    Bus-error
    Bus-error
    
    Introduction
    
    Double-free
    Double-free
    
    Introduction
    
    Out-of-bound
    Out-of-bound
    
    Introduction
    
    Dereference-null-pointer
    Dereference-null-pointer
    
    Introduction
    
    Dangling-and-wild-pointer
    Dangling-and-wild-pointer
    
    Introduction
    
    OOM
    OOM
    
    Introduction
    
    Stack-overflow
    Stack-overflow
    
    Introduction
    
    Buffer-overflow
    Buffer-overflow
    
    Introduction
    
    Memory-leak
    Memory-leak
    
    Memory-leak
    
    Tools
    
    Memory-debugger
    Memory-debugger
    
    Introduction
    
    GC
    GC
    
    Introduction
- CppCoreGuidelines
  CppCoreGuidelines
  - Introduction
  - Read-note
    Read-note
    
    Introduction
    
    Pro-Profiles
    Pro-Profiles
    
    Introduction
  - gsl-suppress
  - GSL-Guidelines-support-library
    GSL-Guidelines-support-library
    
    Introduction
    
    gsl-not_null
    gsl-not_null
    
    Introduction
    
    Microsoft-GSL
    Microsoft-GSL
    
    Introduction
    
    Assertions
    Assertions
    
    Introduction
    
    Utilities
    Utilities
    
    Introduction
    
    Pointers
    Pointers
    
    Introduction
- Guide
  Guide
  - Comment
    Comment
    
    Comment
    
    Doxygen
    Doxygen
    
    Introduction
  - Style-guide
    Style-guide
    
    Introduction
  - Temporary
    Temporary
    
    Introduction
  - Order
    Order
    
    Introduction
  - Header-only-library
    Header-only-library
    
    Introduction
  - Memory-model&&atomic-library
    Memory-model&&atomic-library
    
    Introduction
    
    Design
    Design
    
    Introduction
    
    Multiple-level-memory-model
    Multiple-level-memory-model
    
    Introduction
    
    sciencedirect-Shared-Memory-Application-Programming
    sciencedirect-Shared-Memory-Application-Programming
    
    Introduction
    
    TODO-zhihu-C++11-memory-order
    TODO-zhihu-C++11-memory-order
    
    1
    
    TODO-2
    
    Why-need-memory-model
    Why-need-memory-model
    
    Introduction
    
    Bjarne-Stroustrup
    Bjarne-Stroustrup
    
    Introduction
    
    stackoverflow-C++Memory-model
    stackoverflow-C++Memory-model
    
    Introduction
    
    Herb-Sutter
    Herb-Sutter
    
    Introduction
    
    Guide
    Guide
    
    TODO-CSDN-wxj1992-C++memory-order
    TODO-CSDN-wxj1992-C++memory-order
    
    Introduction
    
    modernescpp-C++Memory-Model
    modernescpp-C++Memory-Model
    
    1-C++Memory-Model.md
    
    2-Sequential-Consistency
    
    Acquire-Release-Fences
    Acquire-Release-Fences
    
    Introduction
    
    Acquire-Release-Semantic
    Acquire-Release-Semantic
    
    Introduction
    
    Atomic-operations-library
    Atomic-operations-library
    
    Introduction
    
    std-memory_order
    std-memory_order
    
    Introduction
    
    Formal-description
    Formal-description
    
    Introduction
    
    Explanation
    Explanation
    
    Introduction
    
    Relaxed-ordering
    Relaxed-ordering
    
    Introduction
    
    Release-Acquire-ordering
    Release-Acquire-ordering
    
    Introduction
    
    Release-Consume-ordering
    Release-Consume-ordering
    
    Introduction
    
    Sequentially-consistent-ordering
    Sequentially-consistent-ordering
    
    Introduction
    
    Full-memory-barrier
    Full-memory-barrier
    
    Introduction
    
    Summary
    Summary
    
    Introduction
    
    Happens-before
    Happens-before
    
    Introduction
    
    Atomic-Boolean
    Atomic-Boolean
    
    Introduction
    
    std-atomic_flag
    std-atomic_flag
    
    Introduction
    
    std-atomic_flag-and-spinlock
    std-atomic_flag-and-spinlock
    
    Introduction
    
    modernescpp-The-Atomic-Flag
    modernescpp-The-Atomic-Flag
    
    Introduction
    
    modernescpp-Atomic-Boolean
    modernescpp-Atomic-Boolean
    
    Introduction
    
    std-atomic_bool-VS-bool
    std-atomic_bool-VS-bool
    
    Introduction
    
    Fence
    Fence
    
    Introduction
    
    std-atomic_signal_fence
    std-atomic_signal_fence
    
    Introduction
    
    compare_exchange
    compare_exchange
    
    Introduction
    
    TODO-herbsutter-write-a-CAS-loop
    TODO-herbsutter-write-a-CAS-loop
    
    Introduction
    
    Implementation
    Implementation
    
    Introduction
    
    cl.cam.ac.uk-C-C++11-mappings-to-processors
    cl.cam.ac.uk-C-C++11-mappings-to-processors
    
    Introduction
    
    TODO-Implementation-on-x86
    TODO-Implementation-on-x86
    
    Introduction
    
    C++VS-Java-memory-model
    C++VS-Java-memory-model
    
    Introduction
    
    cl.cam.uk-Cppmem
    cl.cam.uk-Cppmem
    
    Introduction
  - Type-相关
    Type-相关
    
    Strong-type
    Strong-type
    
    Introduction
    
    Incomplete-type
    Incomplete-type
    
    Introduction
    
    Opaque-data-type
    Opaque-data-type
    
    Introduction
    
    Opaque-pointer
    Opaque-pointer
    
    Introduction
    
    Delete-incomplete-type
    Delete-incomplete-type
    
    Introduction
    
    Check-incomplete-type
    Check-incomplete-type
    
    Introduction
    
    Reflection
    Reflection
    
    Introduction
    
    paper-N3996-Static-reflection
    paper-N3996-Static-reflection
    
    Introduction
    
    vollmann-Metaclasses-and-Reflection-in-C++
    vollmann-Metaclasses-and-Reflection-in-C++
    
    Introduction
    
    thegreenplace-Parsing-C++in-Python-with-Clang
    thegreenplace-Parsing-C++in-Python-with-Clang
    
    Introduction
    
    Library-rttr
    Library-rttr
    
    Introduction
    
    struct-RTTI
    struct-RTTI
    
    Introduction
    
    Interpretation-model
    Interpretation-model
    
    Introduction
    
    Aliasing
    Aliasing
    
    Introduction
    
    Strict-aliasing
    Strict-aliasing
    
    Introduction
    
    stackoverflow-C-language-strict-aliasing-rule
    stackoverflow-C-language-strict-aliasing-rule
    
    Introduction
    
    Type-punning
    Type-punning
    
    Introduction
    
    Aliasing-by-pointer-conversion
    Aliasing-by-pointer-conversion
    
    Introduction
    
    quarkslab-Unaligned-accesse-what-why-solution
    quarkslab-Unaligned-accesse-what-why-solution
    
    Introduction
    
    cmu.edu-EXP36-C
    cmu.edu-EXP36-C
    
    Introduction
    
    pzemtsov -A-bug-story-data-alignment-on-x86
    pzemtsov -A-bug-story-data-alignment-on-x86
    
    Introduction
    
    TODO-memcpy-and-type-punning
    TODO-memcpy-and-type-punning
    
    Introduction
    
    argv-alignment
    argv-alignment
    
    Introduction
    
    TODO-Trap-representation
    TODO-Trap-representation
    
    Introduction
  - Guard
    Guard
    
    Introduction
  - Wrapper
    Wrapper
    
    Introduction
    
    Wrapper-function
  - Compile-time&&run-time
    Compile-time&&run-time
    
    Introduction
    
    Compile-time-computation
    Compile-time-computation
    
    Introduction
    
    Use-static-info-to-optimize
    Use-static-info-to-optimize
    
    Introduction
  - Specifiers
    Specifiers
    
    Introduction
    
    Specifiers
    
    extern
    extern
    
    Introduction
    
    TODO-static
    TODO-static
    
    Introduction
    
    Static-function
    
    Static-in-header-file
    
    C-static
    
    How-compiler-and-linker-resolve-static
    
    inline
    inline
    
    Introduction
    
    cv
    cv
    
    Introduction
  - Configuration-option
    Configuration-option
    
    Introduction
- Performance-optimization
  Performance-optimization
  - Introduction
  - Benchmark
    Benchmark
    
    Introduction
  - Memory
    Memory
    
    Introduction
    
    Small-Buffer-Optimization
    Small-Buffer-Optimization
    
    Introduction
    
    We-Know-Where-You-Live-optimization
    We-Know-Where-You-Live-optimization
    
    Introduction
  - Bound
    Bound
    
    Introduction
  - Optimizing-software-in-C++
    Optimizing-software-in-C++
    
    Introduction
  - developer.51cto-高性能开发的十大武器
    developer.51cto-高性能开发的十大武器
    
    Introduction
- Expert
  Expert
  - Bjarne-Stroustrup
    Bjarne-Stroustrup
    
    Introduction
    
    paper-Foundations-of-C++
    paper-Foundations-of-C++
    
    Introduction
    
    paper-A-rationale-for-semantically-enhanced-library-languages
    paper-A-rationale-for-semantically-enhanced-library-languages
    
    Introduction
    
    TODO-paper-Supporting-SELL-for-High-Performance-Computing
    TODO-paper-Supporting-SELL-for-High-Performance-Computing
    
    Introduction
  - Herb-Sutter
    Herb-Sutter
    
    Introduction
    
    Library-gcpp
    Library-gcpp
    
    Introduction
    
    Effective-Concurrency-Serial
    Effective-Concurrency-Serial
    
    Introduction
    
    Lock-Free-Programming-or-How-to-Juggle-Razor-Blades
    Lock-Free-Programming-or-How-to-Juggle-Razor-Blades
    
    Introduction
    
    PPT
    PPT
    
    Introduction
    
    infoq-Lock-free-Programming-in-C++
    infoq-Lock-free-Programming-in-C++
    
    Introduction
  - Scott-Meyers
    Scott-Meyers
    
    Introduction
    
    Top-C++Serial
    Top-C++Serial
    
    Introduction
  - Andrei-Alexandrescu
    Andrei-Alexandrescu
    
    Introduction
    
    Modern-C++Design
    Modern-C++Design
    
    Introduction
    
    Library-Loki
    Library-Loki
    
    Introduction
  - MattPD-cpplinks
    MattPD-cpplinks
    
    Introduction
  - Martin-Moene
    Martin-Moene
    
    Introduction
    
    span-lite
    span-lite
    
    Introduction
    
    gsl-lite
    gsl-lite
    
    Introduction
    
    string-view-lite
    string-view-lite
    
    Introduction
  - Joboccara-Fluentcpp
    Joboccara-Fluentcpp
    
    Introduction
    
    library-NamedType
    library-NamedType
    
    fluentcpp-Variadic-CRTP
    fluentcpp-Variadic-CRTP
    
    Introduction
    
    Introduction
  - Modernescpp
    Modernescpp
    
    Introduction
  - Bartosz-Milewski
    Bartosz-Milewski
    
    Introduction
    
    C++17-I-See-a-Monad-in-Your-Future
    C++17-I-See-a-Monad-in-Your-Future
    
    Introduction
    
    PPT
    PPT
    
    Introduction
  - Anthony-Williams
    Anthony-Williams
    
    Introduction
    
    CCiA
    CCiA
    
    Introduction
    
    6-Designing-lock-based-concurrent-data-structures
    6-Designing-lock-based-concurrent-data-structures
    
    Introduction
    
    Multithreading-in-C++0x
    Multithreading-in-C++0x
    
    Introduction
    
    Part-6-Lazy-initialization-and-double-checked-locking-with-atomics
    Part-6-Lazy-initialization-and-double-checked-locking-with-atomics
    
    Introduction
  - Sean-Parent
    Sean-Parent
    
    Introduction
    
    library-stlab-libraries
    library-stlab-libraries
    
    Introduction
    
    TODO-Inheritance-is-the-base-class-of-evil
    TODO-Inheritance-is-the-base-class-of-evil
    
    Introduction
    
    PValue-semantic-and-Concept-based-Polymorphism
    PValue-semantic-and-Concept-based-Polymorphism
    
    Introduction
    
    Paper
    Paper
    
    Introduction
    
    Implementation
    Implementation
    
    C++source
    
    C++Source-unique_ptr-version
    
    TODO-gracicot-Concept-Model-Idiom
    TODO-gracicot-Concept-Model-Idiom
    
    Introduction
    
    TODO-mropert-Polymorphic-ducks
    TODO-mropert-Polymorphic-ducks
    
    Introduction
    
    TODO-Better-Code-Runtime-Polymorphism
    TODO-Better-Code-Runtime-Polymorphism
    
    Introduction
    
    Polymorphic-Task-Template-in-Ten
    Polymorphic-Task-Template-in-Ten
    
    Introduction
    
    Small-Object-Optimization-for-Polymorphic-Types
    Small-Object-Optimization-for-Polymorphic-Types
    
    Introduction
  - Erik-Rigtorp
    Erik-Rigtorp
    
    Introduction
    
    Library-SPSCQueue
    Library-SPSCQueue
    
    Introduction
    
    Library-MPMCQueue
    Library-MPMCQueue
    
    Introduction
  - Arthur-O’Dwyer
    Arthur-O’Dwyer
    
    Introduction
    
    library-Quuxplusone-from-scratch
    library-Quuxplusone-from-scratch
    
    Introduction
    
    library-Quuxplusone-ring_view
    library-Quuxplusone-ring_view
    
    Introduction
    
    What-is-Type-Erasure
    What-is-Type-Erasure
    
    Introduction
  - Evan-Klitzke
    Evan-Klitzke
    
    Introduction
- Tools
  Tools
  - Introduction
  - Valgrind
    Valgrind
    
    Introduction
  - gperftools
    gperftools
    
    Introduction
    
    Heap-checker
    Heap-checker
    
    Introduction
  - IDE
    IDE
    
    Introduction
    
    eclipse
    eclipse
    
    Introduction
- C++name-convention
  C++name-convention
  - Introduction
- C++implementation
  C++implementation
  - Introduction
  - Phases-of-translation
    Phases-of-translation
    
    Introduction
    
    Separate-compilation-model.md
    Separate-compilation-model.md
    
    Introduction
    
    One-pass-compiler
  - Preprocess
    Preprocess
    
    Introduction
    
    Implementation-defined-behavior-control
    Implementation-defined-behavior-control
    
    Introduction
    
    include-guard&&pragma-once
    include-guard&&pragma-once
    
    Introduction
    
    Macro
    Macro
    
    Introduction
    
    Plateform-macro
    Plateform-macro
    
    Introduction
    
    Predefined-macros
    Predefined-macros
    
    Introduction
    
    Language-feature-testing-macros
    Language-feature-testing-macros
    
    Introduction
    
    Stringify-and-concatenate-macros
    Stringify-and-concatenate-macros
    
    Introduction
    
    Pros-and-cons-of-macro
  - Compile
    Compile
    
    Introduction
    
    As-if-rule
    As-if-rule
    
    Introduction
    
    Compile-flow
    Compile-flow
    
    Introduction
    
    Name-lookup
    Name-lookup
    
    Introduction
    
    cppreference-Name-lookup
    cppreference-Name-lookup
    
    Introduction
    
    cppreference-Qualified-name-lookup
    cppreference-Qualified-name-lookup
    
    Introduction
    
    ADL
    ADL
    
    ADL
    
    Dependent-name-lookup
    Dependent-name-lookup
    
    Introduction
    
    thegreenplace-Dependent-name-lookup-for-C++templates
    thegreenplace-Dependent-name-lookup-for-C++templates
    
    Introduction
    
    The-template-disambiguator-for-dependent-names
    The-template-disambiguator-for-dependent-names
    
    Introduction
    
    Compile-errors
    Compile-errors
    
    Introduction
    
    using-and-name-lookup
    
    Optimization
    Optimization
    
    Introduction
    
    Copy-elision
    Copy-elision
    
    Introduction
    
    stackoverflow-What-are-copy-elision-and-RVO
    stackoverflow-What-are-copy-elision-and-RVO
    
    Introduction
    
    cppreference-Copy-elision
    cppreference-Copy-elision
    
    Introduction
    
    Optimization-in-function-return
    Optimization-in-function-return
    
    Introduction
    
    Move-and-return
    Move-and-return
    
    Introduction
    
    TODO-return-large-object
    TODO-return-large-object
    
    Introduction
    
    inline
    inline
    
    inline
    
    VS-inline-VS-marco
    
    Prevent-optimization
    Prevent-optimization
    
    Introduction
  - Link
    Link
    
    Linker
    
    Linkage
    Linkage
    
    Linkage
    
    Language-linkage
    Language-linkage
    
    Introduction
    
    const-static-and-linkage
    
    Optimization
    Optimization
    
    Introduction
    
    Link-time-error
    Link-time-error
    
    Introduction
    
    Violations-of-ODR
    Violations-of-ODR
    
    Multiple-definition
    
    Undefined-reference-or-unresolved-external-symbol
    Undefined-reference-or-unresolved-external-symbol
    
    Introduction
    
    Undefined-symbols-vtable-typeinfo
    Undefined-symbols-vtable-typeinfo
    
    Introduction
    
    Type-unsafe-link
    Type-unsafe-link
    
    Introduction
  - ABI
    ABI
    
    Introduction
    
    Application-binary-interface
    Application-binary-interface
    
    Introduction
    
    Call-convention
    Call-convention
    
    Introduction
    
    Call-stack
    Call-stack
    
    Introduction
    
    aaronbloomfield-The-32bit-x86-C-Call-Convention
    aaronbloomfield-The-32bit-x86-C-Call-Convention
    
    Introduction
    
    Library
    Library
    
    Introduction
    
    Position-independent-code
    Position-independent-code
    
    Introduction
    
    thegreenplace-Position-Independent-Code(PIC)-in-shared-libraries
    thegreenplace-Position-Independent-Code(PIC)-in-shared-libraries
    
    Introduction
    
    Relocation
    Relocation
    
    Introduction
    
    Name-mangling
    Name-mangling
    
    Introduction
    
    C++ABI
    C++ABI
    
    Introduction
    
    Itanium-Cpp-ABI
    Itanium-Cpp-ABI
    
    Introduction
    
    Chapter-2-Data-Layout
    Chapter-2-Data-Layout
    
    Introduction
    
    Object-memory-layout
    Object-memory-layout
    
    Introduction
    
    vishalchovatiya-Memory-Layout-of-C++Object-in-Different-Scenarios
    vishalchovatiya-Memory-Layout-of-C++Object-in-Different-Scenarios
    
    Introduction
    
    Dump-object-memory-layout
    Dump-object-memory-layout
    
    Introduction
    
    Polymorphic-type-impl
    Polymorphic-type-impl
    
    Introduction
    
    Virtual-function-table
    Virtual-function-table
    
    Introduction
    
    CSDN-详解virtual-table
    CSDN-详解virtual-table
    
    Introduction
    
    CSDN-C++虚函数和虚函数表详解
    CSDN-C++虚函数和虚函数表详解
    
    Introduction
    
    wikipedia-Virtual-method-table
    wikipedia-Virtual-method-table
    
    Introduction
    
    Thunk
    Thunk
    
    Introduction
    
    shaharmike-Cpp-vtable
    shaharmike-Cpp-vtable
    
    Introduction
    
    Part-1-Basics
    Part-1-Basics
    
    Introduction
    
    RTTI
    RTTI
    
    Introduction
  - Code-analysis-tool
    Code-analysis-tool
    
    Introduction
    
    PC-Lint
    PC-Lint
    
    Introduction
  - Implementation
    Implementation
    
    LLVM
    LLVM
    
    Introduction
    
    LLVM-Design-and-overview
    LLVM-Design-and-overview
    
    Introduction
    
    aosabook-LLVM
    
    LLVM-Core
    LLVM-Core
    
    Introduction
    
    LLVM-Language
    LLVM-Language
    
    Introduction
    
    Clang
    Clang
    
    Clang-Features-and-Goals
    Clang-Features-and-Goals
    
    Introduction
    
    doc
    doc
    
    Introduction
    
    Clang-Static-Analyzer
    Clang-Static-Analyzer
    
    Introduction
    
    Sanitizer
    Sanitizer
    
    UndefinedBehaviorSanitizer
    UndefinedBehaviorSanitizer
    
    Introduction
    
    AddressSanitizer
    AddressSanitizer
    
    Introduction
    
    Assembling-a-Complete-Toolchain
    
    Clang-Tidy
    Clang-Tidy
    
    Introduction
    
    compiler-rt
    compiler-rt
    
    Introduction
    
    TODO-Clang-application
    TODO-Clang-application
    
    Introduction
    
    GCC
    GCC
    
    Introduction
    
    3-GCC-Command-Options
    3-GCC-Command-Options
    
    Introduction
    
    3.1-Option-Summary
    3.1-Option-Summary
    
    Introduction
    
    3.5-Options-Controlling-C++Dialect
    3.5-Options-Controlling-C++Dialect
    
    Introduction
    
    fpermissive
    fpermissive
    
    Introduction
    
    3.9-Options-for-Debugging-Your-Program-or-GCC
    3.9-Options-for-Debugging-Your-Program-or-GCC
    
    Introduction
    
    3.8-Options-to-Request-or-Suppress-Warnings
    3.8-Options-to-Request-or-Suppress-Warnings
    
    Introduction
    
    3.11-Options-That-Control-Optimization
    3.11-Options-That-Control-Optimization
    
    Introduction
    
    3.13-Options-Controlling-the-Preprocessor
    3.13-Options-Controlling-the-Preprocessor
    
    Introduction
    
    3.17-Options-for-Code-Generation-Conventions
    3.17-Options-for-Code-Generation-Conventions
    
    Introduction
    
    Sanitizer
    Sanitizer
    
    Introduction
    
    UndefinedBehaviorSanitizer
    UndefinedBehaviorSanitizer
    
    Introduction
    
    AddressSanitizer
    AddressSanitizer
    
    Introduction
    
    LeakSanitizer
    LeakSanitizer
    
    Introduction
    
    ThreadSanitizer
    ThreadSanitizer
    
    Introduction
    
    Built-in-Functions
    Built-in-Functions
    
    Introduction
    
    10-gcov—a-Test-Coverage-Program
    10-gcov—a-Test-Coverage-Program
    
    Introduction
    
    MSVC
    MSVC
    
    Introduction
    
    GCC-VS-LLVM
    GCC-VS-LLVM
    
    Introduction
- C++cross-plateform
  C++cross-plateform
  - Introduction
  - lib-hedley
    lib-hedley
    
    Introduction
- Undefined-behavior
  Undefined-behavior
  - Introduction
  - llvm-What-Every-C-Programmer-Should-Know-About-Undefined-Behavior
    llvm-What-Every-C-Programmer-Should-Know-About-Undefined-Behavior
    
    Introduction
  - Example-of-undefined-behavior
    Example-of-undefined-behavior
    
    Introduction
C
C
- C
- What-is-new-in-C
- Language-reference
  Language-reference
  - Basic-concept
    Basic-concept
    
    Data-model
    Data-model
    
    Introduction
    
    Objects
    
    Storage-and-linkage
    Storage-and-linkage
    
    Introduction
    
    C-storage-and-linkage
  - Expressions
    Expressions
    
    Introduction
    
    C-Order-of-evaluation
    C-Order-of-evaluation
    
    creference-Order-of-evaluation
    
    TODO-c-sequence-point
  - Array
    Array
    
    Introduction
- Idiom
  Idiom
  - Introduction
- Stype-guide
  Stype-guide
  - C-stype-guide
- Library
  Library
  - Standard-library
    Standard-library
    
    Dynamic-memory-management
    Dynamic-memory-management
    
    Dynamic-memory-management
  - A-list-of-open-source-C-libraries
- Pattern
  Pattern
  - Introduction
- Guide
  Guide
  - Introduction
- Book
Python
Python
- Introduction
- Language
  Language
  - Language-reference
    Language-reference
    
    Introduction
    
    Data-model
    Data-model
    
    Introduction
    
    The-standard-type-hierarchy
    
    Special-method-names
    
    Special-attribute-names
    
    Coroutines
    
    Execution-model
    Execution-model
    
    Execution-model
    
    Python-GC
    
    Python-GIL
    
    Python-interpreter-stack
    
    Type-system
    Type-system
    
    Type-system
  - Developer's-guide
    Developer's-guide
    
    Introduction
- What-is-new
  What-is-new
  - Introduction
  - New-style-class
    New-style-class
    
    Introduction
    
    Metaclass
    Metaclass
    
    Metaclass-Programming-In-Python
- Standard-library
  Standard-library
  - Built-in
    Built-in
    
    Introduction
    
    Built-in-Functions
    Built-in-Functions
    
    Summary-of-python-build-in-function
    
    Hash
    Hash
    
    Introduction
    
    Open
    Open
    
    Introduction
    
    Built-in-Constants
    Built-in-Constants
    
    Introduction
    
    Built-in-Types
    Built-in-Types
    
    Introduction
    
    Built-in-Exceptions
    Built-in-Exceptions
    
    Introduction
  - Functional-Programming-Modules
    Functional-Programming-Modules
    
    Introduction
    
    Iterate
  - Python-Runtime-Services
    Python-Runtime-Services
    
    Introduction
    
    inspect-Inspect-live-objects
- Library
  Library
  - Introduction
  - Event-driven-programming
    Event-driven-programming
    
    Introduciton
    
    Eventlet
    Eventlet
    
    Introduction
    
    Eevent
    Eevent
    
    Introduction
  - Concurrent-server
    Concurrent-server
    
    Introduction
    
    medium-How-Does-Python-Handle-Multiple-Web-Requests
    medium-How-Does-Python-Handle-Multiple-Web-Requests
    
    Introduction
    
    Greenlet
    Greenlet
    
    Introduction
  - Pallets
    Pallets
    
    Flask
    Flask
    
    Deployment-Options
    Deployment-Options
    
    flask-Deployment-Options
  - Static-web-generator
    Static-web-generator
    
    Introduction
- Philosophy
  Philosophy
  - The-Zen-of-Python
- Guide
  Guide
  - Style-guide
    Style-guide
    
    Style-Guide-for-Python-Code
- Paradigm
  Paradigm
  - AOP
    AOP
    
    Introduction
  - Functional-programming
  - Meta-programming
    Meta-programming
    
    Introduction
    
    Reflective
    Reflective
    
    Python-reflection
- Pattern
  Pattern
  - Introduction
- Programming-tool
  Programming-tool
  - Lint
    Lint
    
    Python-lints
    
    Pylint
- How-to
  How-to
  - Iterate
    Iterate
    
    Introduction
  - Lazy-import
    Lazy-import
    
    Lazy-importing
- Glossary
  Glossary
  - Abstract-base-class
- Books
Rust
Rust
- Introduction
- doc
  doc
  - Introduction
  - 4-Understanding-Ownership
    4-Understanding-Ownership
    
    Introduction
  - 10-Generic-Types-Traits-and-Lifetimes
    10-Generic-Types-Traits-and-Lifetimes
    
    Introduction
    
    10.4-Traits-Defining-Shared-Behavior
    10.4-Traits-Defining-Shared-Behavior
    
    Introduction
JavaScript
JavaScript
- Introduction
- DOM
  DOM
- Event-driven-model
  Event-driven-model
  - Introduction
  - JavaScript-event-loop
- Software
  Software
  - Node.js
    Node.js
    
    Introduction
    
    Core-concepts
    Core-concepts
    
    Overview-of-Blocking-vs-Non-Blocking
    Overview-of-Blocking-vs-Non-Blocking
    
    Introduction
    
    How-does-Node.js-manage-timers-internally
    How-does-Node.js-manage-timers-internally
    
    Introduction
  - jQuery
    jQuery
    
    Introduction
- Asynchronous-programming
  Asynchronous-programming
  - Introduction
  - Mozilla-developer-Asynchronous-JavaScript
    Mozilla-developer-Asynchronous-JavaScript
    
    Introduction
  - eloquentjavascript-Asynchronous-Programming
    eloquentjavascript-Asynchronous-Programming
    
    Introduction
  - Async-await
    Async-await
    
    Introduction
- Implementation
  Implementation
  - Babel
    Babel
    
    Introduction
Java
Java
- Introduction
- Guide
  Guide
  - Generic-programming
    Generic-programming
    
    Introduction
- book-Thinking-in-java
  book-Thinking-in-java
  - Introduction
  - About-this-chapter
  - Introduction
  - Introduction-to-Objects
    Introduction-to-Objects
    
    Introduction
  - Everything-is-an-object
Eiffel
Eiffel
- Introduction
Go
Go
- Introduction
- Language-reference
  Language-reference
  - defer
    defer
    
    Introduction
Lisp
Lisp
- Introduction
- Clojure
  Clojure
  - Introduction
- Scheme
  Scheme
  - Introduction
- OOP
  OOP
  - Common-Lisp-Object-System
    Common-Lisp-Object-System
    
    Introduction
Comparison-of-programming-language
Comparison-of-programming-language
- Introduction
- C++VS-C
  C++VS-C
  - Introduction
  - Type-system
- C++VS-Python
  C++VS-Python
  - Introduction
- C++VS-Java
  C++VS-Java
  - Introduction
Cross-language
Cross-language
- Introduction
- SWIG
  SWIG
  - Introduction
- mapbox-jni.hpp
  mapbox-jni.hpp
  - Introduction
  - Read-code
    Read-code
    
    Introduction
Online-compiler
Online-compiler
- Introduction
Auxiliary-compiler
Auxiliary-compiler
- Introduction

`std::any`

std::any type erasure，是对void *的增强。

NOTE: 关于type erasure，参见C++\Idiom\Type-Erasure章节。

microsoft std::any: How, when, and why

bfilipek Everything You Need to Know About std::any from C++17

stackoverflow When should I use std::any

cppreference std::any

open-std Any Library Proposal (Revision 3)

Implementation

fluentcpp How std::any Works

small object optimisation

stackexchange Implementation of std::any

gcc/libstdc++-v3/include/std/any

github thelink2012/any

参见 library-thelink2012-any 章节。