Contents

• Getting started
  • Hello World
  • Comments
  • The standard C++ compilation process
  • Function
  • Visibility of function prototypes and declarations
  • Preprocessor
  • Compiling with GCC
  • Compiling with Clang
  • Compiling with Visual C++ Command Line
  • Compiling with Visual Studio Graphical Interface - Hello World
  • Generating Build Environment with CMake
  • Compiling with GNU make
• Literals
• Basic type keywords
  • char
  • char16_t
  • char32_t
  • int
  • void
  • wchar_t
  • float
  • double
  • long
  • short
  • bool
• Operator precedence
  • Logical && and || operators: short-circuit
  • Unary Operators
  • Arithmetic operators
  • Logical AND (&&) and OR (||) operators
• Floating point arithmetic
• Bit operators
  • | - bitwise OR
  • ^ - bitwise XOR (exclusive OR)
  • & - bitwise AND
  • << - left shift
  • >> - right shift
  • ~ - bitwise NOT (unary complement)
• Bit manipulation
  • Remove rightmost set bit
  • Set all bits
  • Checking a bit
  • Check if an integer is a power of 2
  • Setting a bit
  • Clearing a bit
  • Toggling a bit
  • Changing the nth bit to x
  • Counting bits set
  • Bit Manipulation Application Small to Capital Letter
• Bit fields
• Arrays
  • Array initialization
  • A fixed size raw array matrix that is a 2D raw array
  • Dynamically sized raw array
  • Array size type safe at compile time
  • Expanding dynamic size array by using std::vector
  • Dynamic size matrix using std::vector for storage
• Flow control
  • if
  • if, if ... else
  • else
  • case
  • switch
  • catch
  • throw
  • default
  • try
  • goto
  • break, continue, goto
  • return
• const keyword
  • Const local variables
  • Const pointers
  • Const member functions
  • Avoiding duplication of code in const and non-const getter methods
• Loops
  • for loop
  • while loop
  • do-while loop
  • Loop Control statements: break and continue
  • Declaring variables in conditions
  • Range-Based For
  • Range-for over a sub-range
• mutable keyword
  • mutable lambdas
  • non-static class member modifier
• friend keyword
  • Friend function
  • Friend method
  • Friend class
• keywords
  • Class types
  • decltype
  • class
  • float
  • bool
  • void
  • Controlling alignment
  • Thread-local storage
  • register
  • char
  • char16_t
  • char32_t
  • short
  • long
  • double
  • int
  • wchar_t
  • enum
  • if
  • do
  • else
  • default
  • explicit
  • true
  • false
  • continue
  • const
  • for
  • goto
  • struct
  • case
  • mutable
  • noexcept
  • nullptr
  • catch
  • return
  • signed
  • unsigned
  • Different keywords
  • static
  • this
  • switch
  • throw
  • try
  • break
  • union
  • asm
  • volatile
  • Querying the alignment of a type
  • sizeof
  • typename
• Variable declaration keywords
  • signed
  • unsigned
  • const
  • volatile
  • mutable
  • decltype
• auto keyword
  • auto
  • Basic auto sample
  • auto and expression templates
  • auto const and references
  • Trailing return type
  • Generic lambda (C++ 14)
  • auto and proxy objects
• Pointers
  • Pointer basics
  • Pointer operations
  • Pointer arithmetic
• Type keywords (class, enum, struct, union)
  • class
  • enum
  • struct
  • union
• Classes / structs
  • Class basics
  • Final classes and structs
  • Access specifiers
  • Inheritance
  • Friendship
  • Virtual Inheritance
  • Member types and aliases
  • Accessing class members
  • Private inheritance restricting base class interface
  • Nested classes / structures
  • Multiple Inheritance
  • Static class members
  • Non-static member functions
  • Unnamed struct / class
• std::string
  • std:string
  • Tokenize
  • Conversion to const char
  • Using the std::string_view class
  • Conversion to std::wstring
  • Trimming characters at start / end
  • Lexicographical comparison
  • String replacement
  • Converting to std::string
  • Checking if a string is a prefix of another
  • Accessing a character
  • Looping through each character
  • Splitting
  • Concatenation
  • Conversion to integersfloating point types
  • Converting between character encodings
  • Finding characters in a string
• Enumeration
  • Basic Enumeration Declaration
  • Enumeration in switch statements
  • Scoped enums
  • Enum forward declaration in C++ 11
  • Iteration over an enum
• std::atomic<T>
  • std::atomic<T> specialization in standard library
• std::vector
  • std::vector
  • Accessing Elements
  • Initializing a std::vector
  • Deleting Elements
  • Iterating over std::vector
  • std::vector<bool> : the exception to many rules
  • Inserting elements
  • Using std::vector as a C array
  • Concatenating Vectors
  • Finding an element in std::vector
  • Using a sorted vector for fast element lookup
  • Reducing the capacity of a vector
  • Matrices using vectors
  • Vector size and capacity
  • Iterator / pointer invalidation
  • Find max and min Element and Respective Index in a Vector
  • Functions Returning Large Vectors
  • Converting an array to std::vector
• std::array
  • Initializing an std::array
  • Element access
  • Iterating through the array
  • Checking size of the array
  • Changing all array elements at once
• std::pair
• std::map
  • std::map
  • Accessing elements
  • Inserting elements
  • Searching in std::map or in std::multimap
  • Initializing a std::map or std::multimap
  • Checking number of elements
  • Types of maps
  • Deleting elements
  • Iterating over std::map or std::multimap
  • Creating std map with user-defined types as key
• std::unordered_map
• std::set and std::multiset
  • std::set and std:multiset
  • Changing the default sort of a set
  • Deleting values from a set
  • Inserting values in a set
  • Inserting values in a multiset
  • Searching values in set and multiset
• std::any
• std::variant
  • Basic std::variant use
  • Constructing a std::variant
  • Create pseudo-method pointers
• std::optional
  • Introduction
  • std::optional as return value
  • value_or
  • Using optionals to represent the absence of a value
  • Using optionals to represent the failure of a function
• std::integer_sequence
  • Turn a std::tuple<T>... into function parameters
  • Create a parameter pack consisting of integers
  • Turn a sequence of indices into copies of an element
• std::function
  • std::function used with std::bind
  • std::function with lambda and std::bind
  • Binding std::function to a different callable types
  • Storing function arguments in std::tuple
  • std::function overhead
• std::forward_list
  • Example
  • Methods
• std::iomanip
  • std::setprecision
  • std::setfill
  • std::setiosflags
  • std::setw
• Iterators
  • std::vector iterator
  • std::map iterator
  • Reverse iterators
  • Stream Iterators
  • C iterators (pointers)
  • Write your own generator-backed iterator
• Basic I/O
  • User input and standard output
• File I/O
  • Writing to a file
  • Opening a file
  • Reading from a file
  • Opening modes
  • Reading text file into a std::string
  • Writing files with non-standard locale settings
  • Checking end of file inside a loop condition bad practice
  • Flushing a stream
  • Reading a file into a container
  • Copying a file
  • Closing a file
  • Reading a struct from a formatted text file
• Streams
  • String streams
  • Printing collections with std::iostream
  • Reading a file till the end
  • Parsing files
• Stream manipulators
  • Stream manipulators
  • Output stream manipulators
  • Input stream manipulators
• Metaprogramming
  • Calculating Factorials
  • Iterating over a parameter pack
  • Iterating with std::integer_sequence
  • Tag dispatching
  • Detect if expression is valid
  • if-then-else
  • Manual distinction of types when given any type T
  • Calculating power with C++ 11
  • Generic min/max with variable argument count
• Returning multiple values from a function
  • Using std::tuple
  • Structured bindings
  • Using struct
  • Using Output Parameters
  • Using a Function Object Consumer
  • Using std::pair
  • Using std::array
  • Using output iterator
  • Using std::vector
• References
• Polymorphism
  • Define polymorphic classes
  • Safe downcasting
  • Polymorphism destructors
• Value and reference semantics
• Function call by value vs. by reference
  • Call by value
• Copying vs assignment
  • Assignment operator
  • Copy constructor
  • Copy constructor vs assignment constructor
• Pointers to class / struct members
  • Pointers to member variables
  • Pointers to member functions
  • Pointers to static member variables
  • Pointers to static member functions
• The this pointer
  • this pointer
  • Using the this pointer to access member data
  • Using the this pointer to differentiate between member data and parameters
  • this pointer cv-qualifiers
  • this pointer ref-qualifiers
• Smart pointers
  • Unique ownership (std::unique_ptr)
  • Sharing ownership std::shared_ptr
  • Sharing with temporary ownership std::weak_ptr
  • Using custom deleters to create a wrapper to a C interface
  • Casting std::shared_ptr pointers
  • Writing a smart pointer value_ptr
  • Getting a shared_ptr referring to this
  • Unique ownership without move semantics std::auto_ptr
• Unions
• Templates
  • Templates
  • Basic class template
  • Curiously recurring template pattern (CRTP)
  • Function templates
  • Iterating over a parameter pack
  • CRTP to avoid code duplication
  • Variadic template data structures
  • Partial template specialization
  • Argument forwarding
  • Template specialization
  • Template parameter deduction for constructors
  • Alias template
  • Template template parameters
  • Non-type template parameter
  • Declaring non-type template arguments with auto
  • Explicit instantiation
  • Default template parameter value
• Namespaces
  • Namespaces
  • What are namespaces
  • Argument dependent lookup (ADL)
  • Extending namespaces
  • Using directive
  • Making namespaces
  • Unnamed / anonymous namespaces
  • Compact nested namespaces
  • Inline namespace
  • Namespace alias
  • Aliasing a long namespace
  • Alias declaration scope
• Function overloading
  • Function Overloading
  • What is Function Overloading
  • Return Type in Function Overloading
  • Member Function cv-qualifier Overloading
• Operator overloading
  • Operator Overloading
  • Arithmetic operators
  • Array subscript operator
  • Conversion operators
  • Complex Numbers Revisited
  • Unary operators
  • Comparison operators
  • Assignment operator
  • Named operators
  • Function call operator
  • Bitwise NOT operator
  • Bit shift operators for IO
• Lambdas
  • Lambdas
  • What is a lambda expression
  • Specifying the return type
  • Capture by value
  • Recursive lambdas
  • Default capture
  • Generic lambdas
  • Class lambdas and capture of this
  • Capture by reference
  • Generalized capture
  • Conversion to function pointer
  • Using lambdas for inline parameter pack unpacking
  • Porting lambda functions to C 03 using functors
• Threading
  • Threading
  • Creating a std::thread
  • Passing a reference to a thread
  • Using std::async instead of std::thread
  • Create a simple thread pool
  • Ensuring a thread is always joined
  • Basic Synchronization
  • Using Condition Variables
  • Operations on the current thread
  • Thread operations
  • Thread-local storage
  • Reassigning thread objects
• Value categories
  • Value Category Meanings
  • rvalue
  • xvalue
  • prvalue
  • lvalue
  • glvalue
• Preprocessor
  • Preprocessor
  • Include guards
  • Conditional logic and cross-platform handling
  • Macros
  • X-macros
  • Preprocessor error messages
  • Predefined macros
  • #pragma once
  • Preprocessor Operators
• SFINAE
  • What is SFINAE
  • void_t
  • enable_if
  • is_detected
  • Overload resolution with a large number of options
  • trailing decltype in function templates
  • enable if all enable if any
• Rule of three, five and zero
  • Rule of Zero
  • Rule of Five
  • Rule of Three
  • Self-assignment Protection
• RAII
  • RAII Resource Acquisition Is Initialization
  • Locking
  • FinallyScopeExit
  • ScopeSuccess C++ 17
  • ScopeFail C++ 17
• Exceptions
  • Catching exceptions
  • Rethrow propagate exception
  • Best practice throw by value catch by const reference
  • Custom exception
  • std::uncaught exceptions
  • Function Try Block for regular function
  • Nested exception
  • Function Try Blocks In destructor
  • Function Try Blocks In constructor
• Implementation-defined behavior
  • Size of integral types
  • Char might be unsigned or signed
  • Number of bits in a byte
  • Numeric value of a pointer
  • Ranges of numeric types
  • Value representation of floating point types
  • Overflow when converting from integer to signed integer
  • Order of initialization of globals across TU
  • Underlying type and size of an enum
• Special member functions
  • Default Constructor
  • Copy and swap
  • Destructor
  • Implicit Move and Copy
  • Virtual and Protected Destructors
• Random numbers
  • Random number generation
  • True random value generator
  • Generating a pseudo-random number
  • Using the generator for multiple distributions
• Sorting
  • Sorting
  • Sorting and sequence containers
  • Sorting sequence containers with specifed ordering
  • Sorting sequence containers by overloaded less operator
  • Sorting sequence containers using compare function
  • Sorting sequence containers using lambda expressions
  • sorting with std::map ascending and descending
  • Sorting built-in arrays
• Regular expressions
  • Regular expressions
  • Basic regex match and regex search Examples
  • regex iterator Example
  • Anchors
  • regex replace Example
  • regex token iterator Example
  • Splitting a string
  • Quantifiers
• Perfect forwarding
  • Perfect Forwarding
  • Factory functions
• Virtual member functions
  • Using override with virtual in C++ 11
  • Virtual vs non-virtual member functions
  • Final virtual functions
  • Behaviour of virtual functions in constructors and destructors
  • Pure virtual functions
• Undefined behavior
  • Undefined Behavior
  • Reading or writing through a null pointer
  • Using an uninitialized local variable
  • Accessing an out-of-bounds index
  • Deleting a derived object via a pointer to a base class that doesnt have a virtual destructor.
  • Extending the std or posix Namespace
  • Accessing a dangling reference
  • Integer division by zero
  • No return statement for a function with a non-void return type
  • Invalid pointer arithmetic
  • Incorrect pairing of memory allocation and deallocation
  • Signed Integer Overflow
  • Shifting by an invalid number of positions
  • Modifying a const object
  • Value of an out-of-range enum
  • Multiple non-identical definitions the One Definition Rule
  • Overflow during conversion to or from floating point type
  • Returning from a noreturn function
  • Accessing an object as the wrong type
  • Modifying a string literal
  • Infinite template recursion
  • Access to nonexistent member through pointer to member
  • Destroying an object that has already been destroyed
  • Result of some reinterpret_cast conversions
  • Invalid derived-to-base conversion for pointers to members
  • Invalid base-to-derived static_cast
  • Calling Pure Virtual Members From Constructor Or Destructor
  • Floating point overflow
  • Function call through mismatched function pointer type
  • 290Static cast from bogus void value
• Overload resolution
  • Overload resolution
  • Categorization of argument to parameter cost
  • Exact match
  • Name lookup and access checking
  • Overloading on Forwarding Reference
  • Arithmetic promotions and conversions
  • Overloading on constness and volatility
  • Steps of Overload Resolution
  • Overloading within a class hierarchy
• Move semantics
  • Move semantics
  • Using std::move to reduce complexity from O(n) to O(1)
  • Move constructor
  • Move assignment
  • Re-use a moved object
  • Using move semantics on containers
• Pimpl idiom
• Copy elision
  • Purpose of copy elision
  • Guaranteed copy elision
  • Parameter elision
  • Return value elision
  • Named return value elision
  • Copy initialization elision
• Fold expressions
  • Fold Expressions
  • Unary Folds
  • Binary Folds
  • Folding over a comma
• Unnamed types
  • Unnamed classes
  • As a type alias
  • Anonymous members
  • Anonymous Union
• Singleton
  • Singleton Design Pattern
  • Lazy Initialization
  • Static deinitialization-safe singleton.
  • Subclasses
  • Thread-safe Singeton
• ISO C++ Standard
  • The ISO C Standard
  • Current Working Drafts
  • C 17
  • C 11
  • C 14
  • C 98
  • C 03
  • C 20
• User-defined literals
• Type erasure
  • Type Erasure
  • A move-only std::function
  • Erasing down to a regular type with manual vtable
  • Basic mechanism
  • Erasing down to a contiguous buffer of T
  • Type erasing type erasure with std::any
• Memory management
  • Memory management
  • Free Storage Heap Dynamic Allocation ...
  • Placement new
  • Stack
• Explicit type conversions
  • Explicit type conversions
  • Casting away constness
  • C-style casting
  • Base to derived conversion
  • Conversion between pointer and integer
  • Type punning conversion
  • Conversion by explicit constructor or explicit conversion function
  • Implicit conversion
  • Enum conversions
  • Derived to base conversion for pointers to members
  • void to T
• RTTI
  • RTTI Run-Time Type Information
  • Name of a type
  • dynamic cast
  • The typeid keyword
  • When to use which cast in c
• Standard library algorithms
  • Standard Library Algorithms
  • std next permutation
  • std for each
  • std accumulate
  • std find
  • std count
  • std count if
  • std find if
  • std min element
  • Using std nth element To Find The Median Or Other Quantiles
• Expression templates
  • A basic example illustrating expression templates
  • Basic expression templates on element-wise algebraic expressions
• Scopes
  • Scopes
  • Global variables
  • Simple block scope
• Atomic types
  • Atomic Types
  • Multi-threaded Access
• static assert
  • static assert
  • static assert
• constexpr
  • constexpr
  • constexpr variables
  • Static if statement
  • constexpr functions
• Date and time with std::chrono
  • Date and time using chrono header
  • Measuring time using chrono
  • Find number of days between two dates
• Trailing return type
  • Trailing return type
  • Avoid qualifying a nested type name
  • Lambda expressions
• Function template overloading
  • Function Template Overloading
  • What is a valid function template overloading
• Common compile linker errors
  • Common compilelinker errors GCC
  • undefined reference to
  • error was not declared in this scope
  • fatal error No such file or directory
• Design patterns
  • Design pattern implementation in C
  • Visitor Pattern example in C
  • Adapter Pattern
  • Observer pattern
  • Factory Pattern
  • Builder Pattern with Fluent API
• Optimizations
  • Optimization in C
  • Introduction to performance
  • Empty Base Class Optimization
  • Optimizing by executing less code
  • Using efficient containers
  • Small Object Optimization
• Compiling and building
  • Compiling and Building
  • Compiling with GCC
  • Generating Build Environment with CMake
  • Compiling with Visual Studio Graphical Interface - Hello World
  • Compiling with GNU make
  • Online Compilers
  • Compiling with Visual C Command Line
  • Compiling with Clang
  • The C compilation process
  • Building with SCons
  • Compiling with Code::Blocks Graphical interface
• Type traits
  • Type Traits
  • Type Properties
  • Standard type traits
  • Type relations with std is sameT T
  • Fundamental type traits
• One definition rule
  • One Definition Rule ODR
  • Multiply defined function
  • Inline functions
  • ODR violation via overload resolution
• Unspecified behavio
  • Unspecified behavior
  • Value of an out-of-range enum
  • Evaluation order of function arguments
  • Result of some reinterpret cast conversions
  • Space occupied by a reference
  • Moved-from state of most standard library classes
  • Static cast from bogus void value
  • Result of some pointer comparisons
  • Order of initialization of globals across TU
• Argument dependent name lookup
  • Argument Dependent Name Lookup
  • What functions are found
• Attributes
  • Attributes
  • fallthrough
  • deprecated and deprecatedreason
  • nodiscard
  • noreturn
  • maybe unused
• Internationalization
  • Internationalization in C
  • Understanding C string characteristics
• Profiling
  • Profiling
  • Profiling with gcc and gprof
  • Generating callgraph diagrams with gperf2dot
  • Profiling CPU Usage with gcc and Google Perf Tools
• Return type covariance
  • Return Type Covariance
  • Covariant result version of the base example static type checking.
  • Covariant smart pointer result automated cleanup.
  • Base example without covariant returns shows why theyre desirable
• Non-static member functions
  • Non-Static Member Functions
  • Non-static Member Functions
  • Encapsulation
  • Name Hiding Importing
  • Virtual Member Functions
  • this Pointer
  • Const Correctness
• Recursion
  • Recursion in C
  • Using tail recursion and Fibonnaci-style recursion to solve the Fibonnaci sequence
  • Recursion with memoization
• Callable objects
  • Callable Objects
  • Function Pointers
  • Classes with operator Functors
• Constant class member functions
  • Constant class member functions
  • constant member function
• C++ vs. C++ 11 vs C++ 17
  • Side by Side Comparisons of classic C examples solved via C vs C 11 vs C 14 vs C 17
  • Looping through a container
• Inline functions
  • Inline functions
  • Non-member inline function declaration
  • Non-member inline function definition
  • Member inline functions
  • What is function inlining
• Client server examples
  • Client server examples
  • Hello TCP Client
  • Hello TCP Server
• Header files
  • Header Files
  • Basic Example
  • Templates in Header Files
• Const correctness
  • Const Correctness
  • The Basics
  • Const Correct Class Design
  • Const Correct Function Parameters
  • Const Correctness as Documentation
• Refactoring techniques
  • Refactoring Techniques
  • Goto Cleanup
  • Refactoring walk through
• Parameter packs
  • Parameter packs
  • A template with a parameter pack
  • Expansion of a parameter pack
• Iteration
  • Iteration
  • break
  • continue
  • do
  • for
  • while
  • range-based for loop
• type deduction
  • type deduction
  • Template parameter deduction for constructors
  • Auto Type Deduction
  • Template Type Deduction
• C++ 11 memory model
  • C 11 Memory Model
  • Need for Memory Model
  • Fence example
• Build systems
  • Build Systems
  • Generating Build Environment with CMake
  • Compiling with GNU make
  • Building with SCons
  • Autotools GNU
  • Ninja
  • NMAKE Microsoft Program Maintenance Utility
• Concurrency with OpenMP
  • Concurrency With OpenMP
  • OpenMP Parallel Sections
  • OpenMP Parallel Sections
  • OpenMP Parallel For Loop
  • OpenMP Parallel Gathering Reduction
• Type inference
  • Type Inference
  • Data Type Auto
  • Lambda auto
  • Loops and auto
• Resource management
  • Resource Management
  • Resource Acquisition Is Initialization
  • Mutexes Thread Safety
• Storage class specifiers
  • Storage class specifiers
  • register
  • extern
  • static
  • mutable
  • auto
• Alignment
  • Alignment
  • Controlling alignment
  • Querying the alignment of a type
• Inline variables
  • Inline variables
  • Defining a static data member in the class definition
• Linkage specifications
  • Linkage specifications
  • Signal handler for Unix-like operating system
  • Making a C library header compatible with C
• Curiusly recurring template pattern
  • Curiously Recurring Template Pattern CRTP
  • The Curiously Recurring Template Pattern CRTP
  • CRTP to avoid code duplication
• Using declaration
  • Using declaration
  • Importing names individually from a namespace
  • Redeclaring members from a base class to avoid name hiding
  • Inheriting constructors
• Typedef and type aliases
  • Typedef and type aliases
  • Basic typedef syntax
  • More complex uses of typedef
  • Declaring multiple types with typedef
  • Alias declaration with using
• Layout of object types
  • Layout of object types
  • Class types
  • Arithmetic types
  • Arrays
• C incompatibilities
• Optimization
  • Optimization
  • Inline ExpansionInlining
  • Empty base optimization
• Semaphore
  • Semaphore
  • Semaphore C 11
  • Semaphore class in action
• Thread synchronization
  • Thread synchronization structures
  • std unique lock std shared lock std lock guard
  • std shared lock
  • std call once std once flag
  • Object locking for efficient access.
  • Strategies for lock classes std try to lock std adopt lock std defer lock
  • std condition variable any std cv status
• Debugging
  • C Debugging and Debug-prevention Tools Techniques
  • Static analysis
  • Segfault analysis with GDB
  • Clean code
  • Safe-stack Stack corruptions
  • My C program ends with segfault - valgrind
• Futures and promises
  • Futures and Promises
  • Async operation classes
  • std future and std promise
  • Deferred async example
  • std packaged task and std future
  • std future error and std future errc
  • std future and std async
• More undefined behaviors
  • More undefined behaviors in C
  • Referring to non-static members in initializer lists
• Mutexes
  • std::mutex
  • std::recursive mutex
  • std::scoped_lock (C ++17)
  • std::unique_lock, std::shared_lock, std::lock_guard
  • Strategies for lock classes std::try_to_lock, std::adopt_lock, std::defer_lock
  • std::lock
• Recursive mutex
  • Recursive Mutex
  • std recursive mutex
• Unit testing
  • Unit Testing in C
  • Google Test
  • Catch
• decltype
  • decltype
  • Basic Example
  • Another example
• Digit separators
  • Digit separators
  • Digit Separator
• C++ Containers
  • C Containers
  • C Containers Flowchart
• Arithmetic meta-programming
  • Arithmitic Metaprogramming
  • Calculating power in Olog n
• Contributors