How to Read

This document is broken down into sections and sub-sections. To understand a specific section, you need to understand all of its parent sections as well as any prerequisites that it lists. For example, if section Fruits/Apples/Granny Smith has prerequisites Vegetables/Peas and Fish listed, you'll need to have read ...

• Fruits (just that section, not its sub-sections)
• Fruits/Apples (just that section, not its sub-sections)
• Vegetables/Peas (that section and including ALL of its sub-sections)
• Fish (that section including ALL of its sub-sections)

This is essentially a tree where each section is a node. To understand a node, you need to understand ...

1. its ancestor nodes not including the children of those ancestors (these are the parent sections).
2. any nodes it links to as well as their descendants (these are the sections listed as prerequisites).

Essentials

The following document is my attempt at charting out the various pieces of the modern C++ landscape, focusing on the 80% of features that get used most of the time rather than the 20% of highly esoteric / confusing features. It isn't comprehensive and some of the information may not be entirely correct / may be missing large portions.

The key points of similarity to remember:

1. Scope in C++ is similar to Java/C# (e.g. function scope, class scope, etc...). Variables, classes, etc.. come into and leave out of scopes in similar ways.
2. Compound statements in C++ are similar Java/C#. They create a scope, and things declared in that scope are gone once the scope is exited.
3. Control flow statements in C++ are similar to Java/C#. All the basics are there: for loops, for-each loops, while loops, if-else, switch, etc...
4. Data can exist on the heap or stack similar to Java/C#.

The key point of dissimilarity to remember:

1. C++ does not come with a garbage collector. You are responsible for releasing memory, although the C++ standard library has a lot of pieces to help with this.
2. C++ has a lot of legacy baggage and many edge cases. Compared to Java/C#, the language is powerful but also deeply convoluted with many foot-guns and esoteric syntax / semantics.
3. C++ has a lot of ambiguous behaviour. Compared to Java/C#, the language specifically carves out pieces of the spec and leaves it as platform-specific behaviour, undefined behaviour, etc.. so that compilers have more room to optimize code.

Language Basics

The following are a base set of language constructs required for understanding the rest of the document.

1. The general purpose integral type is int.

2. Variables use the format modifiers type name initializer.

   int a = 0;
   int b (0); // parenthesis
   int c {0}; // curly braces
   

   C++ provides a bewildering number of ways to initialize a variable, each with its own set of edge cases. For best results, stick to the curly braces.

3. Functions use the format modifiers return-type name(param-type1 arg-name1, param-type2 arg-name2, ...) modifiers { body }.

   int myFunction(int a) {
       return x + a;
   }
   

   C++ functions don't necessarily have to be methods (members of a class).

4. Classes use either struct or class.

   struct makes all members of the class public by default, while class makes them all private by default. Members need to be grouped together by visibility, where a visibility (e.g. private) is a label within the class.

   class MyClass {
      int myFunction(int a) {
         return x + a;
      }
   private: // everything under this label is private
      int x {0};
   };
   

5. Source code often comes in pairs: A header file usually contains declarations (e.g. just the function's signature / prototype) while a C++ file usually contains definitions (e.g. the function implementation).

   // MyCode.hpp (header file w/ declarations)
   int myFunction(int a);
   
   // MyCode.cpp (source file w/ definitions)
   #include "MyCode.hpp"
   int myFunction(int a) {
       return x + a;
   }
   

   This isn't required. Source files may contain declarations and / or header files may contain definitions, but the split is typically done for a variety of reasons: faster compile times, sharing the same object across multiple source files, compiling when there are cyclical references, etc..

The following is an example C++ program that prints "hello world" to stdout.

// hello.cpp file
#include <iostream>
int main() {
    std::cout << "hello world\n";
    return 0;
}

The ...

• #include <iostream> pulls in a library that lets you interface with stdout, stderr, and stdin.
• int main() { ... } is the entry point of the program.
• std:cout << ... is what prints to stdout.
• return 0 returns from the main() function, ending the program with an exit code of 0.

Pretty much any modern C++ compiler will compile the above code. The output below uses the GNU C++ compiler to compile the example, then runs the executable.

$ g++ hello.cpp
$ ./a.out
hello world

Compilation Basics

Several C++ compilers exist, the most popular of which are the GNU C++ compiler and LLVM clang. C++ compilers generally follow the same set of steps to go from C++ code to an executable.

1. C++ source files get fed into a preprocessor to generate translation units. A translation unit is the C++ source file after going through modifications based on compiler specifics, platform specifics, libraries used, compile options / library options, etc..
2. Translation unit files get fed into a compiler to generate object files. An object file is the intermediary compiled form of each individual translation unit.
3. Object files get fed into a linker to generate the executable. All object files come together and linkages between them are made to form the final executable.

The C++ language has a lot of legacy baggage, edge cases, and ambiguous behaviour. Regardless of the compiler chosen, at least some of the following warning options should be enabled:

• -Wall - Warns about questionable but easily avoidable constructs.
• -Wextra - Warns about other questionable constructs not covered by -Wall.
• -Wpedantic - Warns about ISO conformance.
• -Weverything - Turns on all warnings.

Most compilers support some or all of the flags above.

Header Files

For each source code file that gets compiled, the compiler needs to know that the entities (variables, functions, classes, etc..) accessed within that file actually exist. The scope at which the compiler keeps track of these entities is per source code file. For example, imagine a source code file that defines a function named myFunction (definition). There are 5 other source code files that call myFunction at some point. Each of those 5 other files is required to tell the compiler what myFunction is (declaration) before it can invoke it.

One way to handle this scenario is to put myFunction's declaration in each source code file that calls it.

OtherClass myFunction(int a);

The problem with doing this is that ...

1. you're duplicating something 5 times, meaning you need to update 5 different places should anything change with the class.
2. you need a declaration for more than just myFunction (e.g. myFunction requires OtherClass, which may require even more entities).
3. as a result of 1 and 2, source code file sizes explode and quickly become unmanageable.

The preferred way to handle this scenario is to put myFunction's declaration into a header file. Then, any file that needs to know about myFunction can use the #include directive.,,

// MyFunction.hpp
#include "OtherClass.hpp"
OtherClass myFunction(int a);

// UsageFile1.cpp
#include "MyFunction.hpp"
myFunction(44);

If an entity is declared once already by an #include, it shouldn't be declared again. For example, imagine that the file Main.cpp includes ParentA.hpp and ParentB.hpp. Both ParentA.hpp and ParentB.hpp then go on to include Child.hpp....

The problem the above example scenario creates is that Child.hpp gets #include'd twice, meaning that everything in it is declared twice. To mitigate this problem, an include guard is typically provided in each header file.

// MyFunction.hpp
#ifndef MY_FUNCTION_H // include guard
#define MY_FUNCTION_H

#include "OtherClass.hpp"
OtherClass myFunction(int a);

#endif

You may notice that sometimes #include puts quotes around the files and sometimes angle brackets. Use quotes when the files are in the same directory structure, angle brackets when the files are coming from some external library.

#include <vector>          // library header
#include "OtherClass.hpp"  // local header

Development Environment

There are many different compilers, IDEs, build systems, and dependency managers for C++.

Common compilers:

• GNU C++ compiler
• LLVM Clang
• Microsoft Visual C++ compiler

Common IDEs:

• Visual Studio Code (open-source, multi-platform), commonly referred to as vscode
• Visual Studio C++ (proprietary, Windows only)
• CLion (proprietary, multi-platform)
• KDevelop (open-source, multi-platform)

Common build systems:

• Make
• Automake / Autoconf / Autotools
• CMake

Common dependency managers:

• Conan
• Vcpkg
• Spack

Of the tools above, the best mixture I've found so far is to use ...

1. LLVM Clang as the compiler (installable via apt -- apt install clang-12)
2. Visual Studio Code as the editor (installable via snap -- snap install --classic code)
3. CMake as the build system (installable via apt -- apt install cmake)
4. Conan as the dependency manager (install deb file from website)
5. C++ extension pack for vscode (install via extension section of vscode)
6. LLVM clangd extension for vscode (install via extension section of vscode)
7. C-Mantic extension for vscode (install via extension section of vscode)

There are basic guides / tutorials for each of these tools available online. With the C++ extensions (5, 6, and 7), vscode (3) works similar to a professional IDE. It will parse a CMake configuration (3) to figure out how the code should be built as well as to provide C++ intellisense / auto-complete / formatting / debugging / etc.. support. Conan (4) integrates with CMake, so intellisense and builds through vscode automatically include the libraries.

{
    "C_Cpp.intelliSenseEngine": "Disabled",
    "C_Cpp.autocomplete": "Disabled",  // So you don't get autocomplete from both extensions.
    "C_Cpp.errorSquiggles": "Disabled", // So you don't get error squiggles from both extensions (clangd's seem to be more reliable anyway).
}

Assuming you have all the software above installed, this cookie cutter template can be used to set up a simple project structure that you can open directly in vscode. The template primes the project by ...

1. creating a main source folder (src/main).
2. creating a test source folder (src/test).
3. setting Conan to download POCO C++ Libraries and Google Test.
4. setting CMake and Conan to use LLVM Clang 12.
5. setting CMake to build using C++20.
6. setting CMake to integrate with Conan.
7. setting CMake to recursive glob compile.

Core Language

The following subsection loosely details core C++ language features. It isn't comprehensive and some of the information may not be entirely correct / may be missing large portions.

Operators

The following is a list of operators available in C++. Some operators are obvious, while others are explained in other sections.

Bitwise Logical Operators

Boolean Logical Operators

Arithmetic Operators

There are implicit rules for how fundamental types get promoted. The general rule of thumb is that the result of the operator is promoted to the operand with the "greater" type. For example, if an int is added to a float, the result will be a float.

These rules are similar to those in other languages (e.g. Java and Python).

Assignment Operators

All assignment operators work similar to those in Java except for the increment and decrement operators. Due to the confusion it causes, Java disallows the increment / decrement from returning a value, meaning that it can't be used in an expression. Not so in C++. In addition to modifying the variable passed as the operand, in C++ these operators also return a result, meaning that it's okay to increment / decrement operator within some larger expression.

int x {3};
int y {(x++) + 2};
// at this point, x is 4, y is 5
int a {3};
int b {(++a) + 2};
// at this point, a is 4, b is 6

Comparison Operator

In addition, the ternary conditional operator is a pseudo operator that takes in 3 operands similar to those found in other high-level languages: CONDITION ? EXPRESSION_IF_TRUE : EXPRESSION_IF_FALSE. It's essentially a shorthand if-else block.

int x {n % 7 == 1 ? 1000 : -1000};
// equiv to...
if (n % 7 == 1) {
    x = 1000;
} else {
    x = -1000;
}

Member Access Operators

These operators are used in scenarios that deal with accessing the members of an object (e.g. element in an array, field of a class) or dealing with memory addresses / pointers. The subscript and and member of object operators are similar to their counterparts in other high-level languages (e.g. Java, Python, C#, etc..). The others are unique to languages with support for lower-level programming like C++. Their usage is detailed in other sections.

Dynamic Object Operators

Size Operator

This operator gets the size of an object in bytes. Note that an object's byte size may not be indicative of the da may include padding required by the platform (e.g. an object requiring 5 bytes may get expanded to 8 bytes because the platform requires 8 byte boundary alignments).

Other Operators

C++ provides a set of other operators such as the ...

• comma operator (,).
• function call operator (()).
• conversion operator (e.g. casting).
• user-defined literal operator (e.g. _)

While it isn't worth going into them in detail here, the reason the language explicitly lists them as operators is because they're overload-able (e.g. operator overloading). Overloading these operators is heavily discouraged since doing so causes confusion.

x = obj['column name', 100]

Variables

C++ variable declarations have the following form: modifiers type name initializer.

• type (required) - Type of variable.

• name: (required) - Name of variable.

• initializer: (optional) - Initial value to assign (object initialization).

  There are multiple ways to initialize a variable, each with their own advantages and disadvantages.

  • braced initialization / uniform initialization: braces used for initialization (e.g. int x {a + b}).
  • equals initialization: equals sign used for initialization (e.g. int x = 5).
  • brace-plus-equals initialization: equals sign and braces used for initialization (e.g. int x = { a + b }).
  • etc..

  ⚠️NOTE️️️⚠️

  The above is an over-simplification. The ways to initialize are vast and complex. See here for a full accounting and here for an hour long talk about the edge cases.

  It seems like the safest bet is to always use brace initialization where possible. Just use the braces as if they were parentheses or braces in Java (specific to the context). The others have surprising behaviour (e.g. they won't warn about narrowing conversions).

• modifiers (optional) - Markers controlling the behaviour / properties of a variable.

  (e.g. const, volatile, constexpr, inline, ...)

int a;     // no initializer -- garbage possibly contained at memory location
int b {};  // empty initializer -- zeros out the memory for the int
int c {0}; // assign to constant 0
int d {c}; // assign to value in c

In C++, variables that are fields (assigned to a class) are called member variables. This section deals with non-member variables (e.g. scoped somewhere other than a class -- global, inside a function, etc..).

Core Types

The following sections list out core C++ types and their analogs. These include numeric types, character types, and string types.

Integral

C++'s core integer types are as follows...

1. short int
2. int
3. long int
4. long long int

The above integer types come in two forms: signed and unsigned. The range of ...

• unsigned integers start at 0 and end at a positive integer.
• signed integers start at a negative integer and positive integer.

By default, the integer types above are signed (speculation). Signed-ness can be explicitly stated by prefixing either signed or unsigned to the type, but if the type is signed the prefix is usually omitted.

Integer types char int, short int, long int, and long long int can optionally omit the int keyword.

The only guarantees for core integer types are that ...

• each integer type tier must be able to cover the same range as the tier before it (e.g. range of short >= range of int).
• unsigned integer types start at 0.
• unsigned integer types overflow behaviour is to wrap to 0.

All other specifics are platform-dependent. Specifically, ...

• range is undefined.
• bit length is undefined (e.g. 8, 16, etc..).
• endian-ness is undefined (e.g. big-endian vs little-endian).
• encoding scheme of signed types is two's complement (as of C++20), but underflow/overflow behaviour of signed types is undefined (e.g. crash, stay at boundary, wrap back around, etc..).

Integer ranges, although platform-specific, are queryable in the climits header.

By default, literals are represented using base10. Literals may be presented in different bases via the prefix.

Integer literals are targeted to specific integer types by their suffix.

Integer types with standardized bit lengths are defined in the cstdlib header.

The minimum and maximum extents of each type are defined in {TYPE}_MIN and {TYPE}_MAX, where {TYPE} doesn't include the _t suffix. For example the maximum value an uint64_t can be is UINT64_MAX.

To expand any integer literal to a ...

• intmax_t, use the macro INTMAX_C(...).
• uintmax_t, use the macro UINTMAX_C(...).
• int{N}_t, use the macro INT{N}_C(...) (where {N} is the bit length).
• uint{N}_t, use the macro UINT{N}_C(...) (where {N} is the bit length).

Floating Point

C++'s core floating point types are as follows...

The specifics of each type are platform-dependent. The only guarantee is that each type has to hold at least the same range as the type before it (e.g. double's range should cover float's range). Other than that, ...

• rounding mode is undefined.
• exponent bit length is undefined.
• mantissa bit length is undefined.
• subnormal number support is undefined.

Floating point characteristics, although platform-specific, are queryable in the cfloat header.

The rounding behaviour of all floating point types is queryable via FLT_ROUNDS, where a ...

• -1 means undetermined.
• 0 means toward zero.
• 1 means toward whichever is nearest.
• 2 means toward positive infinity.
• 3 means toward negative infinity.

The floating point evaluation behaviour is queryable via FLT_EVAL_METHOD, where a ...

• -1 means undetermined.
• 0 means evaluate just to the range and precision of the type.
• 1 means evaluate float and double as double, and long double as long double.
• 2 means evaluate all as long double
• negative value other than -1 means platform-specific behaviour.

Character String

Core C++ strings are represented as an array of characters, where that array ends with a null character to signify its end. This is in contrast to other major platforms that typically structure strings a size integer along with the array (no null terminator).

Individual characters all map to integer types, where literals are defined by wrapping the character in single quotes. Even though they're integers, the signed-ness of each of the types below isn't guaranteed.

Note that char and wchar_t don't have predefined bit lengths. They are platform-dependent. The bit length for...

• char is defined in CHAR_BIT of climits and must be at least 8 bits.
• wchar_t must be equal to or greater than that of char.

Strings literals are wrapped in double quotes instead of single quotes, where they get transformed into an array terminated by a null character.

Typically escaping rules apply to string literals. Unescaped string literals are allowed by adding an R at the end of the literal prefix, which make it so that the ...

1. starting quote requires a custom delimiter immediately after it.
2. finishing quote requires a custom delimited immediately before it.

These delimiter characters are characters that aren't encountered in the contents of the string itself. For example, in u8R"|hello|", the delimiter is | and isn't included in the resulting UTF-8 string.

Void

void is a type that represents an empty set of values. Since it can't hold a value, C++ won't allow you to declare an object of type void. However, you can use it to declare that a function ...

• returns no value (void return).
• accepts no arguments (void parameter list).

Arrays

C++ allows for the creation of arrays of constant length (size of the array must be known at compile-time). Elements of an array are guaranteed to be contiguous in memory (speculation).

• int x[100] - Creates an array of 100 ints where those 100 ints are junk values (data previously at that memory location is not zeroed out).
• int x[] { 5, 5, 5 } - Creates an array of 3 ints where each of those ints have been initialized to 5 (braced initialization).
• int x[] = { 5, 5, 5 } - Same as above (assignment does not do any extra work).
• int x[3] {} - Creates an array of 3 ints where each of those ints are 0 (memory zeroed out -- braced initialization).
• int x[3] = {} - Same as above (assignment does not do any extra work).
• int x[n] - Disallowed by C++ if n isn't a constant. These types of arrays are allowed in C (called variable length arrays / VLA), but not in C++ because C++ has collection classes that allow for sizes not known at compile-time.

Accessing arrays is done similarly to how it is in most other languages, by subscripting (e.g. x[0] = 5). The only difference is that array access isn't bounds-checked and array length information isn't automatically maintained at run-time. For example, if an array has 100 elements, C++ won't stop you from trying to access element 250 -- out-of-bounds array access is undefined behaviour.

One way to think of an array is as a pointer to a contiguous block of elements of the array type. In fact, if an array type gets used where it isn't expected, that array type automatically decays to a pointer type.

int test(int *x) {
   return x[0] + x[1];
}

void run() {
   int x[3] = { 1, 2, 3 };
   int y { test(x) };
}

size_t test(int x[10]) {
   return sizeof(x); // compiler warning that this is returning sizeof(int *)
}

int main() {
   int x[3] = { 1, 2, 3 };
   size_t y { test(x) }; // compiler doesn't complain that test() expects int[10] but this is int[3]
   cout << y;
   return 0;
}

Be careful when using the sizeof operator on an array. If the type is the original array type, sizeof will return the number of bytes taken up by the elements of that array (known at compile-time). However, if the type has decayed to a pointer type, sizeof will return the number of bytes to hold on to a pointer.

int x[3];
int *y {x};  // equiv to setting to &(x[0]);
std::cout << sizeof x;  // should be the size of 3 ints
std::cout << sizeof y;  // should be the size of a pointer

Similarly, range-based for loops won't work if the type has decayed to a pointer type because the array size of that pointer isn't known at compile-time.

int x[3] = {1,2,3};
int *y {x};
for (int i {0}; i < 3; i++) { // OK
   std::cout << y[i] << std::endl;
}
for (int v : x) { // OK
   std::cout << v << std::endl;
}
for (int v : y) { // ERROR
   std::cout << v << std::endl;
}

You may be tempted to use sizeof(array) / sizeof(type) to determine the number of elements within an array. It's a better idea to use std::size(array) instead (found in the iterator header) because it should have logic to workaround and platform-specific behaviours that might cause inconsistent results / unexpected behaviour (speculation).

Pointers

C++ provides types that reference a memory address, called pointers. Variables of these types can point to different memory addresses / objects.

Adding an asterisk (*) to the end of any type makes it a pointer type (e.g. int * is a type that can contain a pointer to an int). A pointer to any object can be retrieved using the address-of unary operator (&). Similarly, the value in any pointer can be retrieved using the dereference unary operator (*).

int w {5};
int *x { &w }; // x points to w
int *y { &w }; // y points to w
int z { *x };   // z is a copy of whatever x points to, which is w, which means it gets set to 5
*x = 7;        // w is set to 5 through x

int **a { &x }; // a points to x, which points to w (a pointer to a pointer to an int)

As shown in the example above, it's perfectly valid to use the dereference operator on the left-side of the equals. It defines where the result of the right side should go.

int w {5};
int *x { &w };  // x points to w
int **y { &x }; // y point to x, which points to w

**y = 7;        // y dereferenced twice and set to 7 -- w should now be 7 

The notation is confusing because asterisk (*) has different meanings. In the context of a ...

• type declaration, an asterisk means that the type is a "pointer to" some other type.
• unary operator in an expression, an asterisk means the object being pointed to should be accessed.
• binary operator in an expression, an asterisk means multiplication.

In addition, a pointer can optionally be set to nothing via the nullptr literal. nullptr is actually of type std::nullptr_t, but the compiler will implicit conversion to/from other pointer types when required.

int *y { nullptr }; // implicit conversion
if (y == nullptr) {
    // report error
}

Pointer Arithmetic

Certain arithmetic operators are allowed on pointers, called pointer arithmetic. Adding or subtracting integer types on a pointer will move that pointer by the number of bytes that makes up its underlying type.

int []x = {1, 5, 7};
int *ptrA { &(x[1]) };  // points to idx 1 of x (5)
int *ptrB { ptrA + 1 }; // points to idx 2 of x (7)

This is similar to array access via the subscript operator. In fact, both arrays and pointers can be accessed in the same way using the subscript operator and pointer arithmetic.

int x[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int *y {x};
*(y+1) = 99;  // same as x[1] = 99
x[2] = 101;   // same as *(y+2) = 101;

Void Pointer

A pointer to the void type means that the type being pointed to is unknown. Since the type is unknown, dereferencing a void pointer isn't possible. In other words, it isn't possible to read or write to the data pointed to by a void * because the underlying type is void / unknown.

int x[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
void *y { x };
*y = 2; // fails

Since the underlying type of the pointer is unknown, pointer arithmetic isn't allowed either.

int x[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
void *y { x };
y = y + 2; // fails

Function Pointer

A pointer to a function means the type being pointed to is a function with some specific structure. All functions have a type associated with them, defined by their return type, parameter type, and owning class if the function is a method.

// type is: int (int, int)
int add(int a, int b) {
    return a + b;
}

To declare a function pointer to a free function or a static class method, write out the function type (return type and parameter list without names) but place the pointer name preceded by an asterisk (*) wrapped in parenthesis where the function name would be. Invoke it just like you would any other function.

int (*func_ptr)(int, int) {}; // unset pointer to a function of structure  int (int, int)

int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

func_ptr = &add;  // point func_ptr to address of add()
func_ptr(1, 2);   // invoke

To declare a function pointer to a non-static class method (member function), the class type needs to be included before the asterisk (*) using the scoped resolution operator (::).

int (MyClass::*func_ptr)(int, int) {}; // unset pointer to a function of structure  int (int, int)  in or inherited from MyClass

MyClass x {};

func_ptr { &MyClass::multiply }; // point to:  int MyClass::multiply(int, int)
(x.*func_ptr)(2, 3);             // provide x as the MyClass instance when invoking

Unlike normal functions, functors cannot be assigned to raw function pointers. A functor's version of a function pointer is a pointer to the function-call operator overload (method).

int (MyFunctor::*func_ptr)(int, int) {};  // unset pointer to a function of structure  int (int, int)  in or inherited from MyClass

MyFunctor x {};

func_ptr { &MyFunctor::operator() };
(x.*func_ptr)(2, 3);            // provide x as the MyClass instance when invoking

Alternatively, to support both functions and functors, the parameter expecting a function pointer should be changed to the std::function or the code doing the invocation should be changed to use the std::invoke wrapper. These wrappers abstract away the differences between pointers to functions and functors.

References

C++ provides a more sanitized version of pointers called references. A reference type is declared by adding an ampersand (&) after the type rather than an asterisk (*), and it implicitly takes the address of whatever is passed into it when it's created.

int w {5};

int *x { &w }; // x points to w
int &y { w };  // y references to w (note address-of operator not used here)

The main difference between pointer types and reference types is that a reference type doesn't need to explicitly dereference to access the object pointed to. The object pointed to by the reference type is accessed as if it were the object itself.

*x = 10;       // x explicitly dereferenced to w and set to 10
y = 15;        // y implicitly dereferenced to w and set to 15

As shown in the example above, assignment to a reference type is assignment on the underlying object being referenced. As such, having the reference type point to a different object isn't possible (referred to as reseating).

Similarly, it's not possible to have a reference to a reference.

int &&z { y }; // this isn't a thing -- fail

Rvalue References

An rvalue reference is similar to a reference except that it tells the compiler that it's working with an rvalue. Rvalue references are declared by adding two ampersands (&&) after the type rather than just one.

// Function return type is an rvalue reference
MyObject && gimmie_an_rvalueref(int x) {
    ...
}

A variable of type rvalue reference is actually an lvalue to an rvalue reference. As such, passing a variable of type revalue reference as a function argument will treat it as if it were an lvalue.

void my_func(MyObject & x) {
    std::cout << "NO RREF";
}
void my_func(MyObject && xRref) {
    std::cout << "YES RREF";
}
MyObject &&a { gimmie_an_rvalueref(42) }; // a has a name, meaning its an lvalue to an rvalue reference
my_func(a);  // calls "NO RREF" version

If you need to pass a variable of type rvalue reference as a function argument, the typical approach is to either never store it as a variable or to use std::forward to ensure the object remains an rvalue reference.

my_func(gimmie_an_rvalueref(42));      // calls "YES RREF" version
my_func(std::forward<MyObject &&>(b)); // calls "YES RREF" version
// NOTE: you MUST specify the full type in std::forward's template parameter -- automatic type inference not supported

Rvalue references are typically used for moving objects (not copying, but actually moving the guts of one object into another). This is done through something called a move constructor, which is explained in another section.

Size

sizeof is a unary operator that returns the size of its operand in bytes as a size_t type. If the operand is a ...

• data type or a variable, it'll return the number of bytes needed to hold that type. For example, ...

  • sizeof char is guaranteed to be 1.
  • sizeof (char &) is guaranteed to be 1.
  • sizeof (char *) is platform dependent, typically either 4 or 8.
  • char * x { "hi" }; sizeof x is same as sizeof (char *) (see above).

• an expression such as a structure/class literal, array literal, or string literal, it'll return the number of bytes needed to hold it. For example, ...

• sizeof "hi" is 3 (added 1 for the null terminator at the end)

• sizeof { 5, 5, 4 } is platform dependent, typically either 12 or 24.

• sizeof (int[3]) is platform dependent, typically either 12 or 24.

• x = int[n]; sizeof x is invalid C++ (variable length arrays allocated on stack are not allowed in C++).

In other words, sizeof returns the size of things known at compile-time. If a variable is passed in, it outputs the size of the data type. For example, if the data type is a struct of type MyStruct, it'll return the number of bytes used to store a MyStruct. However, if the data type is a pointer to MyStruct, it'll return the number of bytes to hold that pointer. That is, you can't use it to get the size of something like a dynamically allocated array of integers.

In certain cases, the compiler may add padding to objects (e.g. byte boundary alignments or performance reasons), meaning that the size returned by sizeof for an object shouldn't be used to make inferences about the characteristics of that object. For example, a long double may get reported as being 16 bytes, but that doesn't necessarily mean that a long double is a 128-bit quad floating point. It could be that only 12 of those bytes are used to represent the floating point number while the remainder is just padding for alignment reasons.

Aliasing

The using keyword is used to give synonyms to types. Other than having a new name, a type alias is the exact same as the originating type.

using IntegerButWithNewName = int;
int x {42};
IntegerButWithNewName y {42};    // same as:  int y {42};
IntegerButWithNewName z {x + y}; // same as:  int z {x + y};

int func(float x);
int func(short x);
int func(int x);
int func(IntegerButWithNewName x);  // NOT ALLOWED -- this overload is same as the overload above

The benefit of type aliasing is that it helps shorten type names, which can be especially useful when using a template.

using BasicGraph = DirectedGraph::Graph<std::string, std::map<std::string, std::string>, std::string, std::map<std::string, std::string>>;

BasicGraph removeLimbs(const BasicGraph &g);

Constant

For types, any part of that type can be made unmodifiable by adding a const immediately after it.

int a {5};                // a is changeable   -- set to 5
int const x {a};          // x is unchangeable -- set to 5 (value in a)
int * const y {&a};       // y is an unchangeable pointer to a changeable int -- set to a (points to a)
int const * const z {&x}; // z is an unchangeable pointer to a unchangeable int -- set to x (points to x)

The simplest way to interpret const-ness of a type is to read it from right-to-left.

One caveat to the above is that a type beginning with const is the same as the first part of that type having const applied on it.

const int x {5};  // same as int const x {5}

All of the examples above were for fundamental types. Appending a const on a class type works exactly the same way: None of its fields are modifiable ever, even by its own methods.

struct MyStruct {
    int x {5}
};

MyStruct const inst {};
inst.x = 5;  // compiler error

Volatile

Adding the keyword volatile before a type makes it immune to compiler optimizations such as operation re-ordering and removal. Mutations and accesses, no matter how irrelevant they may seem, are kept in-place and in-order by the compiler.

int f(int a) {
    int x {a};
    x = 6;
    int y {x};
    int x {y};
    return x; // at this point, x is always 6
}

A compiler might be able to deduce that the function above always returns 6, and as such may replace the operations it performs with simply just returning 6. Adding volatile to the type of the variable prevents this from happening.

int f(int a) {
    volatile int x {a};  // marked as volatile
    x = 6;
    int y {x};
    int x {y};
    return x;
}

Using volatile is important when working with embedded devices, where platform-specific memory locations often need to be accessed in a specific order / at specific intervals in seemingly useless ways (e.g. kicking a watchdog by writing 0 to a memory location but never reading that memory location).

Common Attributes

If a variable has been deprecated, adding a [[deprecated]] attribute will allow the compiler to generate a warning if it sees it being used.

[[deprecated("Warning -- this is going away in the next release")]]
int my_variable;

Implicit Conversion

An implicit type conversion is when an object of a certain type is converted (cast) automatically, without code explicitly changing the object to a different type. For example, long x {1} implicitly converts the int literal in the initializer to a long.

int x {5};
long y {x};  // int to long

The most common types of implicit conversions are ...

• when a pointer of a certain type gets implicitly converted to a void pointer (e.g. int * to void *).
• when a numeric type gets converted to another numeric type via promotion rules (e.g. int to float).
• when a numeric type gets converted to a bool type (e.g. 0 to false)

Depending on the operation performed or how an object is initialized, the results of an implicit conversion may do something specific to that platform and/or compiler implementation.

Explicit Conversion

An explicit type conversion is the opposite of an implicit type conversion. It's when an object of a certain type is explicitly converted (cast) to another type in code.

long x {5L};
int y {static_cast<int>(x)};   // long to int

Explicit type conversions come in two forms:

• Named conversions are the official way to cast in C++.
• C-style casts are the legacy way to cast in C++.

Named conversions should be preferred over C-style casts. Any C-style cast can be performed through a named conversion.

Named Conversions

Named conversion functions are a set of (seemingly templated) functions to convert an object's types. These functions provide safety mechanisms that aren't available in other older ways of casting.

• const_cast removes the const modifier from an object's type.

  void func(const MyType &t) {
      T &moddable_t { const_cast<MyType &>(t) };
  }
  

  Performing this type of conversion should only be done in extreme situations since it breaks contracts.

• static_cast forces the reverse of an implicit conversion.

  int a[] {1,2,3,4};
  int *b { a };  // ok, implicit conversion (decay to pointer)
  void *c { b }; // ok, implicit conversion
  int *d { c };  // error, can't go in reverse
  int *e { static_cast<int *>(c) }; // ok
  

  In the above example, a uint32_t * implicitly converts to void *, but not the reverse. A static_cast makes going in reverse possible. However, that doesn't mean it's always safe to do. For example, uint32_t reads may need to be aligned to 4 byte boundaries on certain platforms. If the void * was arbitrary data (e.g. coming in over a network), it might cause a crash to just treat it as a uint32_t * and start reading.

  ⚠️NOTE️️️⚠️

  Why does a uint32_t* implicitly convert to a void *? Recall that void * just means "pointer to something unknown", which is something the language is okay automatically / implicitly converting.

• reinterpret_cast forces a reinterpretation of an object into an entirely different type.

  int a[] {1,2,3,4};
  int *b { a };   // ok, implicit conversion (decay to pointer)
  short *c { b }; // error, you can't convert from an int* to a short* (not even with a static_cast because it's not an implicit conversion)
  short *d { reinterpret_cast<int *>; } // ok
  

• narrow_cast is similar to static_cast for numerics, except it ensures that no information loss occurred.

  uint32_t a { 70000 };                     // ok
  uint16_t b { static_cast<uint16_t>(a) };  // ok, but since uint16_t has a max of65535, this object is mangled
  uint16_t c { narrow_cast<uint16_t>(a) };  // runtime exception, narrow_cast sees that the object will be mangled
  

  ⚠️NOTE️️️⚠️

  Is this part of the standard? The book seems to give the code for narrow_cast and looking online it looks like people have their own implementations?

C-style Casts

C-style casts are similar to casts seen in Java. The type is bracketed before whatever is being evaluated.

int x { (int) 9999999999L };

The problem with C-style casting is that it doesn't provide the same safety mechanisms as named conversions do (e.g. inadvertently strip the const-ness). Named conversions provide these safety mechanisms and as such should be preferred over C-style casts. Any C-style cast can be performed using a named conversion.

Object Lifecycle

In C++, an object is a region of memory that has a type and a value (e.g. a class instance, an integer, a pointer to an integer, etc..). Contrary to other more high-level languages (e.g. Java), C++ objects aren't exclusive to classes (e.g. a boolean is an object).

An object's life cycle passes through the following stages:

1. memory allocated
2. constructor invoked
3. destructor invoked
4. memory deallocated

The storage duration of an object starts from when its memory is allocated and ends when that memory is deallocated. An object's lifetime, on the other hand, starts when its constructor completes (meaning the constructor finishes) and ends when its destructor is invoked (meaning when the destructor starts).

Since C++ doesn't have a garbage collector performing cleanup like other high-level languages, it's the user's responsibility to ensure object lifetimes. The user is responsible for knowing when objects should be destroyed and ensuring that objects are only accessed within their lifetime.

The typical storage durations supported by C++ are...

• automatic storage duration - scoped to duration of some function within the program.
• static storage duration - scoped to the entire duration of the program.
• thread storage duration - scoped to the entire duration of a thread in the program.
• dynamic storage duration - allocated and deallocated on request of the user.

Static Objects

By default, an object declared within a function is said to be an automatic object. Automatic objects have automatic storage durations: start at the beginning of the block and finish at the end of the block. When the keyword static (or extern in some cases) is added to the declaration, the storage duration of the function changes.

At global scope, if an object is declared as static or extern, storage duration of the object spans the entire duration of the program. The difference between the two is essentially just visibility:

• static makes it so it's accessible to only the translation unit it's declared in.
• extern makes it so it's accessible to other translation units as well as the translation unit it's declared in.

static int a { 0 }; // static variable
extern int b { 1 }; // static variable (accessible outside translation unit)

At function scope, the storage duration of objects declared as static starts at the first invocation of that function and ends when the program exits.

int f1() {
    static int z {0}; // static variable
    z += 1;
    return z;
}

At class level, the storage duration of a member (field or method) declared as static is essentially the same as if it were declared at global scope (they aren't bound to an individual instance of the class the same way a normal field or method is). The only differences are that the static member is accessed on the class itself using the scoped resolution operator (::) and that static members that are fields must be initialized at global scope.

class X {
public:
    static int m;         // static member (field initialized at end)
    static int f1() {     // static member (method)
        m += 1;
        return m;
    }
};

X::m = 0;                // initialize static member

If the thread_local modifier is added before static (or extern), each thread gets its own copy of the object. That is, the storage duration essentially gets changed to when the thread starts and ends.

thread_local static can be shortened to just thread_local (it's assumed to be static).

static int a {0};
thread_local static int b {1};
thread_local extern int c {2};

Dynamic Objects

An object can be created in an ad-hoc manner, such that its storage duration is entirely controlled by the user. The operator ...

• new allocates a new object and calls its constructor.
• delete calls the destructor of some object and deallocates it.

Both keywords work with pointers: new returns a pointer while delete requires a pointer. To create a new object, use new followed by the type.

int * ptr { new int };
*ptr = 0;
delete ptr;

Objects may be initialized directly within the new invocation just as if it were an automatic object initialization. The only caveat is that equals initialization and brace-plus-equals initialization won't work because the equal sign is already being used during new (speculation -- it doesn't work but I don't know the exact reason). As such, braced initialization is the best way to initialize a dynamic object.

int * ptr { new int {0} }; // initialize to 0
delete ptr;

The same process can be used to create an array of objects. Unlike automatic object arrays, dynamic arrays don't have a constant size array length restriction. However, the return value of new will decay from an array type to a pointer type.

When deleting a dynamic object array, square brackets need to be appended to delete operator: delete[]. Doing so ensures that the destructor for each object in the array gets invoked before deallocation.

int * ptr { new int[len] };  // len is some non-constant positive integer, decayed to pointer type because array length can be non-constant.
delete[] ptr;

Braced initialization may be used when declaring dynamic arrays so long as the size of the array is at least the size of the initialization list.

int * ptr1 { new int[10] {1,2,3} };  // initialize the first 3 elems of a 10 elem array
int * ptr2 { new int[2] {1,2,3} };   // throws exception  (size too small for initializer list)
int * ptr3 { new int[n] {1,2,3} };   // okay -- so long as n >= 3
delete[] ptr1;
delete[] ptr2;
delete[] ptr3;

By default, dynamic objects are stored on a block of memory called the heap, also sometimes referred to as the free store.

Functions

C++ function declarations and definitions have the following form: prefix-modifiers return-type name(parameters) suffix-modifiers

• return-type (required) - Type returned by function.

• name: (required) - Name of function.

• parameters (required) - Parameter list of function.

• prefix-modifiers (optional) - Markers controlling the behaviour / properties of a function.

  (e.g. static, virtual, constexpr, [[noreturn]], inline, ...)

• suffix-modifiers (optional) - Markers controlling the behaviour / properties of a function.

  (e.g. noexcept, const, final, override, volatile, ...)

int add(int x, int y) {
    return x + y;
}

In C++, functions that are ...

• methods (assigned to a class) are called member functions.
• global are called free functions.

This section deals with free functions.

Overloading

Function overloading is when there are multiple functions with the same name in the same scope. For free functions, each function overload must have the same return type and a unique set of parameters.

bool test(int a) { return a != 0; }
bool test(double a) { return a != 0.0; }
bool test(int a, int b) { return a != b; }

When an overloaded function is called, the compiler will try to match argument types against parameter types to figure out which overloaded function to call. If no exact match can be found, the compiler attempts to obtain a correct set of types through a set of conversions.

int num { 1 };
test(1);  // calls the first overload in the code above:  bool test(int a);

Argument Matching

When a function is called but the arguments types don't match the parameter list types, the compiler attempts to obtain a correct set of types through a set of conversions on the arguments. For example, if a parameter expects a reference to a constant object but what gets passed into the argument is an object, the argument is automatically converted to a constant object and its reference is used.

bool test(const int &obj) { ... }

int x {};
test(x); // x is turned into a "const int" and passed in as a reference

For floating point and integral types, the compiler will widen or narrow the if the exact type isn't found.

bool test(int32_t a) {
    std::cout << a;
    return a != 0;
}

float x {1.5};
test(x); // automatic narrowing

Similarly, the compiler will convert between signed and unsigned integral types if the exact integral type isn't found.

bool test(uint32_t a) {
    std::cout << a;
    return a != 0;
}

int64_t x {10};
test(x); // automatic narrowing and change to unsigned

When function overloads are involved, the candidate with the arguments matching most closely is the one chosen.

Main Function

The entry-point to any C++ program is the main function, which can take one of three possible forms:

1. int main()

   No arguments.

2. int main(int argc, char* argv[])

   Command-line arguments, where argv is an array of size argc containing the null-terminated command-line arguments. On most modern platforms, the first argument is the path of the executable.

3. int main(int argc, char* argv[], EXTRA_PLATFORM_SPECIFIC_PARAMS)

   Same as the above except extra arguments are supplied that are platform-specific.

All three forms return an integer known as an exit code. On most modern day platforms, an exit code of 0 means success. If the code doesn't return an exit code, 0 is assumed.

#include <iostream>

int main(int argc, char* argv[]) {
    std::cout << "hello world!" << ' ' << argv[0];
    return 0;
}

Variadic

A variadic function is one that takes in a variable number of arguments, sometimes called varargs in other languages. A function can be made variadic by placing ... as the final parameter. The arguments for this final parameter are called the variadic arguments.

The variadic arguments for a function are accessible through functionality provided by the cstdargs header.

#include <cstdargs>

float avg(size_t n, ...) {
    va_list args;
    va_start(args, n);
    float sum {0};
    while (size_t i {0}; i < n; i++) {
        sum += va_args(args, float);
    }
    va_end(args);
    return sum /= n;
}

• va_list - Access point to variadic arguments.
• va_start - Initializes access to variadic arguments (requires the va_list variable and the expected count of variadic arguments).
• va_args - Gets the next variadic argument (requires the va_list variable and the expected type).
• va_end - Tears down access to the variadic arguments (requires the va_list variable).

In addition, the va_copy() can be used to copy one va_list to another. The source will need to be initialized before the copy (via va_start). Once va_copy returns, copy will already be initialized (no need for va_start) but will need to be torn down before the function exits (via va_end).

#include <cstdargs>

float add_and_mult(size_t n, ...) {
    va_list args;
    va_list args2;
    va_start(args, n);
    va_copy(args2, args);  // 1st param is dst, 2nd param is src
    float res {0};
    while (size_t i {0}; i < n; i++) {
        res += va_args(args, float);
    }
    va_end(args);
    while (size_t i {0}; i < n; i++) {
        res *= va_args(args2, float);
    }
    va_end(args2);
    return res;
}

No Exception

In certain cases, it'll be impossible for a function to throw an exception. Either the function (and the functions it calls into) never throws an exception or the conditions imposed by the function make it impossible for any exception to be thrown. In such cases, a function may be marked with the noexcept keyword. This keyword allows the compiler to perform certain optimizations that it otherwise wouldn't have been able to, but it doesn't necessarily mean that the compiler will check to ensure an exception can't be thrown.

int add(int a, int b) noexcept {
    return a + b;
}

Common Attributes

If a function has no possibility of ever gracefully returning to the caller, adding a [[noreturn]] attribute will allow the compiler to make certain optimizations and provide / remove relevant warnings around that function.

[[noreturn]] int add(int a, int b) {
    throw "error";
}

If a function returns something and it's of vital importance that the return value should be used by the invoker, adding a [[nodicard]] attribute will allow the compiler to generate a warning.

[[nodiscard]] Result perform(int a) {
    // perform some computation
    if (result < 0) {
        return ERROR_CODE;
    }
    return SUCCESS_CODE;
}

If a function's parameter isn't used but it's inclusion in the parameter list is intentional, adding a [[maybe_used]] attribute will allow the compiler to remove any warnings that it might otherwise show up about it being unused.

int add(int a, int b, [[maybe_unused]] int c) {
    return a + b;
}

If a function has been deprecated, adding a [[deprecated]] attribute will allow the compiler to generate a warning if it's being used.

[[deprecated("Warning -- this is going away in the next release")]]
int add(int a, int b) {
    return a + b;
}

Enumerations

C++ enumerations are declared using enum class.

enum class MyEnum {
   OptionA,
   OptionB,
   OptionC
};

MyEnum x {MyEnum::OptionC};

switch (x) {
    case MyEnum::OptionA:
        ...
        break;
    case MyEnum::OptionB:
        ...
        break;
    case MyEnum::OptionC:
        ...
        break;
    default:
        break;
}

An enumeration may be brought into scope via using to remove the need to prefix with the enumeration's name.

switch (x) {
    using enum MyEnum;
    case OptionA:
        ...
        break;
    case OptionB:
        ...
        break;
    case OptionC:
        ...
        break;
    default:
        break;
}

enum MyEnum { // no class keyword
   OptionA,
   OptionB,
   OptionC
};

MyEnum x {OptionC}; // this is okay -- don't have to use MyEnum::OptionC
int y {OptionC};    // this is okay -- options are integers

Classes

C++ classes are declared using either the struct keyword or class keyword. When ...

• struct is used, the default visibility of class members is public.
• class is used, the default visibility of class members is private.

Public and private visibility are the same as in most other languages: private members aren't accessible outside the class while public members are. In C++ nomenclature, ...

• methods are commonly referred to as member functions.
• fields are commonly referred to as member variables.

class MyStruct {
    private:
    int count;
    bool flag;

    public:
    char name[256];
    void add() {
        count += 1;
        flag = false;
    }
};

C++ classes that contain only data are called plain-old-data classes (POD), and they're typically created using the struct keyword so as their members are all accessible by default.

struct MyStruct {
   int count;
   char name[256];
   bool flag;
};

This Pointer

Non-static methods of a class have access to an implicit pointer called this, which allows for accessing that instance's members. As long as the class member doesn't conflict with any parameter name of the method invoked, the usage of that name will implicitly reference the this pointer.

The member-of-pointer operator (->) allows for dereferencing a pointer and accessing a member on the result in a more concise form.

class MyStruct {
    private:
    int count;
    bool flag;

    public:
    f1(int count) {
        this->count = count;  // same as (*this).count = count
        flag = false;
    }

    f2(int count, bool flag) {
        this->count = count;  // same as (*this).count = count
        this->flag = flag;    // same as (*this).flag = flag
    }
}

Constant

For fields of a class, a const before the type has the same meaning as a const variable at global scope: It's unmodifiable.

For methods of a class, a const after the parameter list indicates that the class's fields won't be modified (read-only). This is a deep check rather than a shallow check, meaning that the entire call graph is considered when checking for modification.

struct Inner {
    int x {5};
    int y {6};
    void change(int n) {
        x = n;
    }
};

struct X {
    int a {0};
    Inner inner;
    void test1() const {
        a = 5;  // NOT okay -- no mutation allowed
    }
    void test2() const {
        inner.x = 15; // NOT okay -- no mutation allowed, even though this is deeper down
    }
    void test3() const {
        inner.change(15); // NOT okay -- method being invoked must be const (otherwise mutation might happen)
    }
};

Volatile

For fields of a class, a volatile before the type has the same meaning as a volatile variable at global scope: The compiler won't optimize its access.

For methods of a class, a volatile after the parameter list indicates that all fields should be treated as volatile (access won't be optimized away or re-ordered). This is a deep check rather than a shallow check, meaning that the entire call graph requires volatile.

struct Inner {
    int x {5};
    int y {6};
    void change(int n) volatile {
        x = n;
        x = n;
        x = n;
    }
};

struct X {
    int a {0};
    int b {0};
    void test() volatile {
        a = b;
        b = a;
        inner.change(15); 
    }
};

Common Attributes

If a class has been deprecated, adding a [[deprecated]] attribute will allow the compiler to generate a warning if it sees it being used.

[[deprecated("Warning -- this is going away in the next release")]]
int add(int a, int b) {
    return a + b;
}

Static

For fields of a class, a static before the type indicates that the function is independent of any instances of the class type: a static field points the same memory across all instances.

For methods of a class, a static before the return type indicates that the function is independent of any instances of the class type, meaning that the only class fields that a static method can access are static fields.

static methods and fields are accessed using the scope resolution (::) operator, where the scope is the class itself.

struct X {
    static int a {1};
    int b {0};
    static void double_it() {
        a *= 2; 
    }
};

X::double_it();  // call using scoped resolution

Construction

C++ classes are allowed one or more constructors that initialize the object. Similar to Java, each constructor should have the same name as the class itself, no return type, and a unique parameter list.

class MyStruct {
    private:
    int count;
    bool flag;

    public:
    MyStruct() {
        count = 0;
        flag = false;
    }

    MyStruct(int initialCount, bool initialFlag) {
        this->count = initialCount;
        this->flag = initialFlag;
    }
}

The above constructors are using the member-of-pointer operator (->) to access the this pointer. Non-static methods of a class have access to an implicit pointer called this, which allows for accessing that instance's members. The member-of-pointer operator allows for dereferencing a pointer and accessing a member on the result in a more concise form.

this->count = 0;  // same as (*this).member = 0

If a class offers constructors, the least error-prone way to invoke it is to use braced initialization: MyStruct x { 5, true }. The reason is that C++ has so many object initialization foot-guns that, while simpler methods may work (e.g. MyStruct x(5, true)), those methods may end up being interpreted by the compiler as something else that's entirely different (e.g. function declaration).

Classes that don't have any constructors declared get an implicit zero-arg constructor that zeros out the memory of that class (speculation). If the class is a POD, a braced initialization that is ...

• empty will zero out the memory for all fields, (implicit default constructor).
• non-empty will set the individual fields, in the order they're declared in.

struct MyStruct {
   int count;
   char name[256];
   bool flag;
};

MyStruct a;                    // initialized to zeroed out memory (via implicit constructor)
MyStruct b {};                 // initialized to zeroed out memory (via implicit constructor)
MyStruct b {5, "steve", true}; // initialized to supplied arguments

If a class does explicitly declare constructors, the implicit zero-arg constructor won't be generated. If desired, a zero-arg constructor may be declared with the default behaviour of the implicit zero arg constructor by adding = default instead of a method body.

class MyStruct {
    private:
    int count;
    bool flag;

    public:
    MyStruct() = default;
    MyStruct(int initialCount, bool initialFlag) {
        this->count = initialCount;
        this->flag = initialFlag;
    }
}

A field may be initialized to a value either through default member initialization or the member initializer list. For default member initializations, the initialization is done directly in the field's declaration.

struct MyStruct {
   int count {5};
   char name[256] {"steve"};
   bool flag {true};
};

In contrast, a member initializer list is a comma separated list of braced initializations for the fields of a class. It's specified just before a constructor's body.

struct MyStruct {
    int count;
    bool flag;

    MyStruct(): count{0}, flag{false} {
    }
}

Each item in the comma separated list is called a member initializer.

Destruction

C++ classes are allowed an explicit cleanup function called a destructor (e.g. closing an open file handle, zeroing out memory for security purposes, etc..). A destructor is declared similarly to a constructor, the only differences being ...

1. a tilde must appear just before the class / function name.
2. it doesn't take in any arguments.

class MyStruct {
    private:
    int count {5};
    bool flag {true};

    public:
    ~MyStruct() {
        // do some cleanup here
    }
};

Destructors must never be called directly by the user. Treat any destructor as if it were marked with noexcept. That is, an exception should never be thrown in a destructor. When an exception gets thrown, the call stack unwinds. As each function exits, the destructors for automatic variables of that function get invoked. Another exception getting thrown while one is already in flight means two exceptions would be in flight, which isn't supported.

If a destructor isn't declared, an empty one is implicitly generated.

Copying

There are two built-in mechanisms for copying in C++: the copy constructor and copy assignment.

A copy constructor is a constructor that has a single parameter, a reference to a const object of the same type. By default, classes are implicitly provided with a default copy constructor if one hasn't been explicitly declared by the user. The copy semantics of this default copy constructor is to copy each field individually, called a member-wise copy.

Member-wise copying may not be the correct way to copy in certain cases, in which case a copy constructor should be explicitly provided with the correct copy semantics.

class MyStruct {
    ...

    MyStruct(const MyStruct &orig) {
        this->db = DatabaseConnection {orig.db.host, orig.db.port}; // make a new db connection instead of using orig's
        this->max = orig.max;
    }
}


MyStruct x {host, port};
MyStruct y {x}; // both x and y are independent and equal, but y has its own DatabaseConnection

Similarly, copy assignment is a method invoked when the assignment operator is used, called an operator overload. Unlike copy constructors, copy assignment is required to clean up any resources in the destination object prior to copying. By default, classes are implicitly provided with a copy assignment method if one hasn't been explicitly declared by the user. The copy semantics of this default method is to assign each field individually, called a member-wise copy.

class MyStruct {
    ...

    MyStruct& operator=(const MyStruct &orig) {
        if (this != &other) { // only do if assigning to self
            this->db.close(); // close existing db connection
            this->db = DatabaseConnection {orig.db.host, orig.db.port}; // make a new db connection
            this->max = orig.max;
        }
        return *this; // return self -- this should always be the case??
    }
}

To suppress the compiler from allowing copying or assignment of an object, add = delete after both signatures instead of specifying a body. This is important if the object holds on to an uncopyable resource such as a lock.

class MyStruct {
    ...

    MyStruct(const MyStruct &orig) = delete;
    MyStruct& operator=(const MyStruct &orig) = delete;
}

class MyStruct {
    ...

    MyStruct(const MyStruct &orig) = default;
    MyStruct& operator=(const MyStruct &orig) = default;
}

// copy
MyStruct(MyStruct &&orig) = default;
MyStruct& operator=(MyStruct &&orig) = default;
// move
MyStruct(MyStruct &&orig) = default;
MyStruct& operator=(MyStruct &&orig) = default;
// destructor
~MyStruct() = default;

Moving

There are two built-in mechanisms for moving in C++: the move constructor and move assignment. Moving is different from copying in that moving actually guts the insides (data) of one object and transfers it into another, leaving that object in an invalid state. If the scenario allows for it, moving is oftentimes more efficient than copying.

A move constructor is a constructor that has a single parameter, an rvalue reference to an object of the same type. By default, classes are implicitly provided with a default move constructor if one hasn't been explicitly declared by the user. The move semantics of this default move constructor is to copy each field rather than actually move anything, called a member-wise copy.

class MyStruct {
    ...

    MyStruct(MyStruct &&orig) noexcept {
        this->str_ptr = orig.str_ptr;
        this->max = orig.max;
        orig.str_ptr = nullptr; // mark orig object as invalid
        orig.max = -1; // mark orig object as invalid
    }
}

MyStruct a {};
MyStruct c { std::move(a) };  // std::move returns MyObject && type, which calls MyObject's move constructor
// a is in an invalid state

In the example above, the move constructor has noexcept set to indicate that it will never throw an exception. Move constructors that can throw exceptions are problematic for the compiler to use. If a move constructor throws an exception, the source object will likely enter into an inconsistent state, meaning the program will likely be in an inconsistent state. As such, if the compiler sees that the move constructor can throw an exception, it'll prefer to copy it instead.

Similarly to the move constructor, move assignment is a method invoked when the assignment operator is used, called an operator overload. It has the same parameter list and it shouldn't throw exceptions either (noexcept), the only difference is that it returns a reference to itself at the end.

class MyStruct {
    ...

    MyStruct& operator=(MyStruct &&orig) {
        if (this != &other) { // only do if assigning to self
            this->str_ptr = orig.str_ptr;
            this->max = orig.max;
            orig.str_ptr = nullptr; // mark orig object as invalid
            orig.max = -1; // mark orig object as invalid
        }
        return *this; // return self -- this should always be the case??
    }
}

class MyStruct {
    ...

    // copy
    MyStruct(MyStruct &&orig) = default;
    MyStruct& operator=(MyStruct &&orig) = default;
    // move
    MyStruct(MyStruct &&orig) = default;
    MyStruct& operator=(MyStruct &&orig) = default;
    // destructor
    ~MyStruct() = default;
}

Default Implementations

The compiler may automatically generate default implementations for some member functions (e.g. default constructor), called special member functions. However, under certain conditions, it may choose to omit generating them. If the compiler chooses to not generate a default implementation where one was expected, it's possible to force the compiler to generate that function by explicitly declaring it but replacing the function body = default.

struct MyClass {
    MyStruct() = default;        // forcefully generate default constructor
}

Deleted Implementations

The compiler may automatically generate default implementations for some member functions (e.g. default constructor), called special member functions. There are two ways to turn off these automatically generated member functions. The first way is to declare the function but make it privately scoped so that nothing outside can access it.

struct MyClass {
    ...
private:
    MyStruct() { };             // default constructor is private
}

The second way is to explicitly declare the function but mark it as deleted by appending = delete in place of the function body.

struct MyClass {
    MyStruct() = delete;        // default constructor is forcefully deleted
}

Inheritance

In C++, a class inherits another class by, just after its name, appending a colon (:) followed by the name of the parent class.

class MyChild : MyParent {
};

Like in most other object oriented languages, a child class...

• can access the non-private members of any of the classes it inherits.
• is assignable to the type of any of the classes it inherits.

MyChild c {};
MyParent p {x}; // MyChild inherits from MyParent, meaning that it's assignable to MyParent

To be able to override a method in a child class the same way as it's done in other languages (e.g. Java), the base call must have the virtual keyword prepended on the method, making it a virtual method. Similarly, any method that overrides a virtual method should have the override keyword appended just after the parameter list.

struct MyParent {
    virtual int virt_method() { ... }
    int non_virt_method() { ... }
};

struct MyChild : MyParent {
    virtual int virt_method() override { ... }
};

If the base class and child class have the exact same non-virtual method, which method gets called depends on the type of the variable.

struct MyParent {
    virtual int virt_method() { ... }
    int non_virt_method(int a) { ... }
};

struct MyChild : MyParent {
    virtual int virt_method() override { ... }
    int non_virt_method(int a) { ... }
};


MyChild c {};
MyChild  &cref {x};
MyParent &pref {x};
cref.non_virt_method(0);  // calls MyChild::non_virt_method()
pref.non_virt_method(0);  // calls MyParent::non_virt_method() even though object is a MyChild

To prevent a method from being overridable at all, add the final keyword just after the parameter list.

struct MyParent {
    virtual int methodA() final { ... }
};

struct MyChild : MyParent {
    virtual int methodA() { ... }  // ERROR HERE -- not allowed
};

Similarly, to prevent the entire class itself from being inheritable, add the final keyword just after the name.

struct MyParent final {
    virtual int methodA() { ... }
};

C++ chains constructor and destructor invocations appropriately as expected. The one caveat is that destructor, if not a virtual method, will use the method resolution mechanism described above: If the type of the variable doesn't match the object (variable type is the base class but object is not), the wrong destructor gets invoked, resulting in object potentially not cleaning up resources (e.g. closing file handles).

struct MyParent {
    virtual int v1() { ... };
    ~MyParent() { ... };
};

struct MyChild : MyParent {
    virtual int v1() { ... };
    ~MyChild() { ... };
};


MyParent *c {new MyChild{}};
delete c;  // calls MyParent's destructor instead of MyChild's destructor

When inheritance is involved, it's almost always a good idea to enforce a virtual destructor. Since not having a virtual destructor sometimes makes sense (e.g. user determined that it's safe to omit it and as such omitted it to improve performance), the compiler won't produce a warning if it isn't virtual.

struct MyParent {
    virtual int v1() { ... };
    virtual ~MyParent() { ... };
};

Interfaces

Interfaces and abstract classes are supported in C++, but not in the same way as other high-level languages. The C++ approach to interfaces is to explicitly mark certain methods as requiring an implementation. This is done by appending = 0 to the method declaration.

struct MyParent {
    virtual int virt_method() = 0;
    int non_virt_method() = 0;
};

A method that is both a virtual method and requires an implementation is called a pure virtual method. A class that contains all pure virtual methods is called a pure virtual class.

struct MyParent {
    virtual int v1() = 0;
    virtual int v2() = 0;
    virtual ~MyParent() {};  // also okay to do   "virtual ~MyParent() = default"
};

As shown in the example above, a pure virtual class should have a virtual destructor. While not required, failing to do so means that the wrong destructor may get invoked if the type of the variable doesn't match the object (variable type is the base class but object is not), resulting in class resources being left open (e.g. file handles).

Operator Overloading

C++ classes support operator overloading.

Operators are overload-able in two ways. To overload an operator the first way, introduce a method but instead of naming it, add the operator keyword followed by the operator being overloaded. The parameters and return type of the method need to match whatever types the operator is intended to deal with.

struct MyClass {
    ...

    // MyClass + int -- notice whitespace between 'operator' keyword and operator -- this is okay.
    MyClass operator +(int rhs) const {
        MyClass ret { this->value + x };
        return ret;
    };

    // MyClass + MyClass
    MyClass operator+(const MyClass &rhs) const {
        MyClass ret { this->value + rhs.value };
        return ret;
    }

    // MyClass += MyClass
    MyClass& operator+=(const MyClass &rhs) {
        this->value += x->value;
        return *this;
    }
};

To overload an operator the second way, introduce a function (not a method) using the operator keyword followed by the operator being overloaded. In the examples above, the left-hand side was the this pointer. When using this second way, a left-hand side needs to be explicitly provided as the first parameter while the right-hand side is the second argument.

// MyClass + int
MyClass operator+(const MyClass &lhs, int rhs) {
    MyClass ret { lhs.value + x };
    return ret;
};

// MyClass + MyClass
MyClass operator+(const MyClass &lhs, const MyClass &rhs) {
    MyClass ret { lhs.value + rhs.value };
    return ret;
}

// MyClass += MyClass
MyClass & operator+=(MyClass &rhs, const MyClass &rhs) {
    lhs.value += rhs.value;
    return lhs;
}

Note how the const keyword is added to the method in cases where the operator shouldn't modify itself. Similarly, when the argument for a parameter shouldn't be changed, const is used on that parameter. const-ness depends on the scenario. For example, the second operator+ requires two references to const types.

MyClass operator+(const MyClass &lhs, const MyClass &rhs) {
    MyClass ret { lhs.value + rhs.value };
    return ret;
}

Those consts ensure that the operands aren't changed in the method. Imagine that you're performing x = y + z. It doesn't make sense for y or z to get modified.

The signature could have just as well been modified to be the types themselves rather than const references, in which case both the left-hand side and right-hand side would get copied on invocation of the method (modifications to copies don't matter).

MyClass operator+(MyClass lhs, MyClass rhs) {
    MyClass ret { lhs.value + rhs.value };
    return ret;
}

Certain operators can have default implementations in which the compiler generates the body of the function. In simple cases, the default implementation is good enough.

struct MyClass {
    ...
    bool operator==(const MyDouble&) const = default; 
};

Three-way Comparison Overloading

The three-way comparison operator (<=>), also called the spaceship operator, is a streamlined way of providing ordering comparison operators for a class. Typically, if a class is orderable / sortable, it should provide operator overloads for the following operators:

• less-than (<)
• less-than or equal (<=)
• greater-than (>)
• greater-than or equal (>=)

The three-way comparison operator provides all 4 of the above operators through a single operator overload, and may additionally provide equality (==) and inequality (!=) operators in certain conditions.

Rather than just returning a boolean, the three-way comparison operator's return type breaks-down comparisons into 3 categories based on the idea of equality and equivalence:

• Strong ordering (std::strong_ordering) - A == B means that the A and B are indistinguishable. One may be substituted for the other without any side-effects.

  Strong ordering is sometimes also referred to as total ordering.

  std::strong_ordering::less       // a < b
  std::strong_ordering::equal      // a == b
  std::strong_ordering::equivalent // same as equal
  std::strong_ordering::greater    // a > b
  

  struct Time {
      int hour;
      int minute;
  
      std::strong_ordering operator<=>(const Time& rhs) const {
          if (hour < rhs.hour) {
              return std::strong_ordering::less;
          } else if (hour > rhs.hour) {
              return std::strong_ordering::greater;
          } else {
              if (minute < rhs.minute) {
                  return std::strong_ordering::less;
              } else if (minute > rhs.minute) {
                  return std::strong_ordering::greater;
              } else {
                  return std::strong_ordering::equal;
              }
          }
      }
  
      bool operator==(const Time& other) const = default;
  };
  

• Weak ordering (std::weak_ordering) - A == B means that the A and B aren't guaranteed to be indistinguishable. They are equivalent but not equal (one can't be substituted for the other). For example, the strings "hello world" and "HELLO WORLD" are equivalent if you ignore case, but one can't necessarily be substituted for the other.

  std::weak_ordering::less         // a < b
  std::weak_ordering::equivalent   // a is equivalent to b (this is NOT equality, it's equivalence)
  std::weak_ordering::greater      // a > b
  

  struct Rectangle {
      int length;
      int width;
      
      std::weak_ordering operator<=>(const Rectangle& rhs) const {
          int lhs_area { length * width };
          int rhs_area { rhs.length * rhs.width };
          if (lhs_area < rhs_area) {
              return std::weak_ordering::less;
          } else if (lhs_area > rhs_area) {
              return std::weak_ordering::greater;
          } else {
              return std::weak_ordering::equivalent;
          }
      }
      
      bool operator==(const Rectangle& other) const = default;
  };
  

• Partial ordering (std::partial_ordering) -- same as std::weak_ordering, but with the caveat that objects may not be comparable at all. For example, the floating point number 5.5 is not comparable at all to NaN: 5.5 == NaN, 5.5 < NaN, and 5.5 > NaN are all false.

  std::partial_ordering::less        // a < b
  std::partial_ordering::equivalent  // a is equivalent to b (this is NOT equality, it's equivalence)
  std::partial_ordering::greater     // a > b
  std::partial_ordering::unordered   // a was not comparable to b
  

  struct FloatRectangle {
      float length;
      float width;
  
      std::partial_ordering operator<=>(const FloatRectangle& rhs) const {
          float lhs_area { length * width };
          float rhs_area { rhs.length * rhs.width };
          if (lhs_area < rhs_area) {
              return std::partial_ordering::less;
          } else if (lhs_area > rhs_area) {
              return std::partial_ordering::greater;
          } else if (lhs_area == rhs_area) {  // if both sides are nan, this still evaluates to false
              return std::partial_ordering::equivalent;
          } else {
              return std::partial_ordering::unordered;
          }
      }
  
      bool operator==(const FloatRectangle& other) const = default;
  };
  

All of the examples above provide a default implementation for the equality operator (==). That's because, when the three-way comparison operator overload has a non-default implementation, it doesn't provide support for the equality and inequality operators. The user has to provide those operator overloads.

However, when the three-way overload has a default implementation, the equality and inequality operators are automatically provided. A default three-way overload implementation first compares parent classes (left to right, in order they were declared -- C++ has multiple inheritance), then compares each member variable (in order they were declared).

struct Time {
    int hour;
    int minute;
    std::strong_ordering operator<=>(const Time& rhs) const = default;
};

if ((a <=> b) == std::strong_ordering::equal) {
    // do something
} else {
    // do something else
}

Conversion Overloading

C++ classes support both implicit type conversions and explicit type conversions via operator overloading. Implicit type conversions are represented as operator overload methods where the name of the operator being overloaded is the destination type and the return type is omitted.

struct MyClass {
    ...
    operator int() const {
        return this-> value / 42;
    }
};
...
MyClass cls {};
int x {cls}; // triggers operator overload method

Explicit type conversions are enabled the same way as implicit type conversions, except the overload method is preceded by the explicit keyword. The explicit keyword makes it so that conversion to that type requires a static_cast

struct MyClass {
    ...
    explicit operator int() const {
        return this-> value / 42;
    }
};
...
MyClass cls {};
int x {static_cast<int>(cls)};  // static_cast required to trigger operator overload method

Const / Volatile Overloading

In addition to following the same function overloading rules as free functions, a member function may be overloaded based on whether the this pointer is to a volatile and / or const object.

class MyClass {
public:
    int get_data() {
        std::cout << "non-const non-volatile\n";
        counter += 1;
        return counter;
    }
    int get_data() const {
        std::cout << "const non-volatile\n";
        return counter;
    }
    int get_data() volatile {
        std::cout << "non-const volatile\n";
        counter += 1;
        return counter;
    }
    int get_data() volatile const {
        std::cout << "const volatile\n";
        return counter;
    }
private:
    int counter;
};


MyClass c1{};
c1.get_data(); // prints "non-const non-volatile"
const MyClass c2{};
c2.get_data(); // prints "const non-volatile"
volatile MyClass c3{};
c3.get_data(); // prints "non-const volatile"
const volatile MyClass c4{};
c4.get_data(); // prints "const volatile"

Reference Overloading

In addition to following the same function overloading rules as free functions, a member function may be overloaded based on whether the this reference is an l-value or r-value. To target ...

• l-value, add an ampersand (&) after the parameter list
• r-value, add two ampersands (&&) after the parameter list

The benefit of reference overloading is being able to define a version of the function with efficient move semantics when the object is transient.

// THIS EXAMPLE WAS LIFTED FROM https://docs.microsoft.com/en-us/cpp/cpp/function-overloading?view=msvc-170#ref-qualifiers
class MyClass {
public:
    MyClass() {/*expensive initialization*/}
    std::vector<int> get_data() & {
        std::cout << "lvalue\n";
        return _data;
    }
    std::vector<int> get_data() && {
        std::cout << "rvalue\n";
        return std::move(_data);
    }
private:
    std::vector<int> _data;
};


MyClass c {};
auto v {c.get_data()}; // get a copy. prints "lvalue".
auto v2 {C().get_data()}; // get the original. prints "rvalue"

Functors

A functor, also called a function object, is a class that you can invoke as if it were a function because it has an operator overload for function-call.

struct MyFunctor {
    int operator()(int y) const { return -y + x; }
private:
    int x {5};
};

MyFunctor inst{};
inst(15);  // computes -15 + 5

Functors are useful because they allow for state (via fields) and parameterization (via constructor arguments) but still retain a function-like syntax.

Friends

A friend is a function or class that can access the non-public members of some other class that it wasn't declared in.

For friend functions, the class to be accessed needs to declare the function's prototype (function declaration) before implementations of a friend function (function definition) can exist. The prototype is included in the class just like any other member function, but the friend prefix modifier is tacked on.

class MyClass {
public:
    friend int addAndNegate(MyClass& obj, int n);  // prototype
private:
    int x {0};
};

int addAndNegate(MyClass& obj, int n) {  // implementation -- friend of MyClass
    return -(n + obj.x);
}

// test
MyClass obj{};
int t = addAndNegate(obj,5);

For friend classes, the class to be accessed needs to specify which outside class is able to access it using friend class.

class MyClass {
public:
    friend class MyFriend;  // state that MyFriend can access MyClass's non-public members
private:
    int x {0};
};

class MyFriend {
public:
    int addAndNegate(MyClass& obj, int n) {  // function in MyFriend accessing non-public members of MyClass
        return -(n + obj.x);
    }
};


// test
MyFriend obj_friend{};
MyClass obj{};
int t = obj_friend.addAndNegate(obj,5);

Friend functions and friend classes may also target templated types.

class MyClass {
public:
    template<typename T> friend int addAndNegate(MyClass& obj, T n);  // every addAndNegate(MyClass&, T) will be a friend
private:
    int x {0};
};

ostream& operator<<(ostream &os, const MyClass &obj) {
    os << obj.x << "\n";
    return os;
}

User-defined Literals

C++ provides a way for users to define their own literals through the use of operator overloading, called user-defined literals. User-defined literals wrap built-in literals and perform some operation to convert them to either another type or another value. It's identified by a unique suffix that starts with an underscore (e.g. _km).

The operator overload is identified by two quotes followed by the suffix.

Distance operator"" _km (long double n) {
    return Distance {n * 1000.0};
}

Distance operator"" _mi (long double n) {
    return Distance {n * 1609.34};
}

Distance d { 1.2_km + 4.0_mi };

As stated above, user-defined literals must wrap an existing built-in literal type.

Note that, for ...

• numerics, the widest possible C++ type is used for both integral (unsigned long long int) and floating point (long double).
• characters, each character type gets its own definition.
• strings, each string type gets its own definition.

The last definition in the table above, raw, will get a character string of any numeric literal used.

const char * operator"" _as_str (const char * n) {
    std::cout << "input str: " << n;
    return n;
}

123.5e+12_as_str;  // outputs "input str: 123.5e+12"

The C++ standard library makes use of user-defined literals in various places, but its identifiers don't require an underscore (_) prefix.

• Date-time API (chrono header): std:chrono::duration d { 2h + 15ms }.
• Complex numbers API (complex header): std::complex<double> { (1.0 + 2.0i) * (3.0 + 4.0i) }.
• String API (string): std::string str { "hello"s + "world"s }.

Lambdas

Lambdas are unnamed functors (not functions) that are expressed in a succinct form. Lambdas in C++ work similarly to lambdas in other high-level languages. They capture copies of / references to objects from the outer scope such that they can be used for whatever processing the functor performs.

For example, consider the following functor.

// define
constexpr struct MyFunctor {
    MyFunctor(int x) {
        this->x = x;
    };

    constexpr int operator()(int a) const {
        return a + x;
    }
private:
    int x;
};

// instantiate
MyFunction f1{ 5 };

// invoke
f1(42);

The functor above can be written much more succinctly as a lambda.

// define and instantiate
auto f2 { [x=5] (int a) -> int { return a + x; } };

// invoke
f2(42);

The general syntax of a lambda is as follows: [capture-list] (parameter-list) modifiers -> return-type { body }. The subsections below detail this general syntax.

Capture List

[capture-list] is a required part of [capture-list] (parameter-list) modifiers -> return-type { body } that defines and sets member variables inside the functor. It's a comma separated list where each element is a list is a variable to capture as a member variable.

There are 3 different ways to capture member variables.

• Copy a variable from the outer scope.

  To create a copy of an individual variable into the functor, put the variable's name in the capture list.

  int x {5};
  int y {6};
  // explicitly copy x and y from outer scope
  auto f { [x, y] (int z) -> int { return x + y + z; } };
  

  One way to avoid listing out individual variable names is to put = as the first element of the capture list. When = is present, missing member variables will automatically get copied as member variables.

  int x {5};
  int y {6};
  // explicitly copy x and implicitly copy y from outer scope
  auto f { [=, x] (int z) -> int { return x + y + z; } };
  

  If used within an enclosing class, the this pointer can be captured.

  auto f { [this] (int z) -> int { return z + this->x; } };   // capture this as a pointer
  auto f { [*this] (int z) -> int { return z + this->x; } };  // capture a COPY OF *this and pass it in as a pointer
  

  ⚠️NOTE️️️⚠️

  It's mentioned that prior to C++20, automatic copy capturing ([=]) would pull in this. That feature has been deprecated.

• Reference a variable from the outer scope.

  To create reference to an individual variable into the functor, put the variable's name in the capture list preceded by an ampersand (&).

  int x {5};
  int y {6};
  // explicitly reference x and y from outer scope
  auto f { [&x, &y] (int z) -> int { return x + y + z; } };
  

  One way to avoid listing out individual variable names is to put & as the first element of the capture list. When & is present, missing member variables will automatically get referenced as member variables.

  int x {5};
  int y {6};
  // explicitly reference x and implicitly reference y from outer scope
  auto f { [&, &x] (int z) -> int { return x + y + z; } };
  

• Initialize a variable using an expression.

  When a variable name is followed by = and an expression, the expression is evaluated and captured.

  int x {5};
  int y {6};
  auto f { [mod_x=x/2, mod_y=y/2] (int z) -> int { return mod_x + mod_y + z; } };
  

  This is especially useful for capturing an object by moving it (as opposed to copying it or referencing it).

  auto f { [o=std::move(my_obj)] (int z) -> int { return o.do_something(z); } };
  

Parameter List

(parameter-list) is a required part of [capture-list] (parameter-list) modifiers -> return-type { body } that defines the parameter list of the functor's function-call operator.

auto f1 { [] (int x, int y) -> int { return x + y; } };
auto f2 { [] (int x, int y = 99) -> int { return x + y; } };  // default args
auto f3 { [] (auto x, auto y) -> int { return static_cast<int>(x + y); } };  // templated params (compiler deduces types based on usage)

Lambda parameter lists are defined similarly to standard function parameter lists. It's common for a lambda's parameter list to use template parameters via auto as is done in f3 of the example above. The reason for using auto is that the lambda can still work even if you don't know / can't predict the exact types of the arguments passed in (e.g. you know the arguments will be integral types, but you don't know exactly which exact integral types).

Return Type

return-type is an optional part of [capture-list] (parameter-list) modifiers -> return-type { body } that defines the return type of the functor's function-call operator. The syntax of using an arrow and defining the type after the parameter list is called the trailing return syntax.

auto f1 { [] (int a, int b) -> int { return a+b; } };
auto f2 { [] (MyObject* v) -> const MyObject& { return v[5]; } };

When a lambda doesn't provide a return type, the return type is implicitly auto. The compiler uses standard template parameter type deduction rules to determine what the return type should be.

auto f3 { [] (int a, int b) { return a+b; } };  // return deduced to int
auto f4 { [] (MyObject* v) { return v[5]; } };  // return deduced to MyObject

In f4, even though v[5] returns a const MyObject &, type deduction rules evaluate it to const MyObject (not a reference). That means f4 returns a copy of the object at v[5] rather than a reference to the real thing. Type deduction rules such as the one here may end up causing subtle bugs if you aren't careful.

Another option is to explicitly return decltype(auto), which copies the exact type being returned.

auto f5 { [] (MyObject* v) -> decltype(auto) { return v[5]; } };  // return deduced to const MyObject&

Modifiers

modifiers is an optional part of [capture-list] (parameter-list) modifiers -> return-type { body } that lists the modifiers of the functor's function-call operator. Except for the following special cases, modifiers work the same way that they do for normal functions.

• The function-call operator is set to be a constexpr function if it meets the requirements of being a constant expression. You can force it to be a constant expression by adding constexpr as one of the modifiers.

  auto f1 { [] (int x, int y) constexpr -> int { return x + y; } };  // force as constant expression
  

• The function-call operator is set to be a const function. You can force this off by adding mutable as one of the modifiers.

  auto f2 { [] (int x, int y) mutable -> int { return x + y; } };    // make non-const
  

Template Parameters

A lambda may have template parameters added by injecting template parameters in angle brackets between [capture-list] and (parameter-list) of the lambda declaration [capture-list] (parameter-list) modifiers -> return-type { body }.

auto f1 { [] <typename T>(T x, T y) -> T { return x + y; } };

This is useful in cases where you need to be more explicit with the types of parameters / return types (auto is too loose). The most obvious case is with containers, where you likely want the underlying container type listed.

// f2 and f3 will do the same thing when passed a std::vector, but f3 is much more explicit.
auto f2 { [] (auto& v) -> const auto& { return v[7]; } };
auto f3 { [] <typename T>(std::vector<T>& v) -> const T& { return v[7]; } };

Templates

Templates are loosely similar to generics in other high-level languages such as Java. A template defines a class or function where some of the types and code are unknown, called template parameters. Each template parameter in a template either maps to a ...

• a type (e.g. int).
• an integral value available at compile-time (e.g. 5).
• floating point value available at compile-time (e.g. 5.5f).
• an enumeration value available at compile-time (e.g. MyEnum::Value).
• object pointer type value available at compile-time (e.g. &MyClass::MyStaticField).
• function pointer type value available at compile-time (e.g. &MyClass::MyStaticMember).
• std::nullptr_t value available at compile-time (e.g. nullptr).

Templates are created using the template keyword, where the template parameters are a comma separated list sandwiched within angle brackets. When the user makes use of a template, its template parameters get substituted with what the user specified.

template <typename X, typename Y, typename Z, int N>
struct MyClass {
    X perform(Y &var1, Z &var2) {
        return (var1 + var2) * N;
    }
};

As shown above, each template parameter for a ...

• type substitution is prefixed with the keyword typename. The keyword class may be used instead of typename. The meaning is exactly the same (typename should be preferred).
• value substitution is prefixed with the type name.

To use a template, use it just as you would a non-template but provide substitutions (template instantiation). To instantiate a class template, use the class as if it were a normal class but immediately after the class name add in a comma separated list of template parameter substitutions sandwiched within angle brackets. These substitutions should be in the same order as the template parameters.

MyClass<float, int, int, 2> obj {}; // X = float, Y = int, Z = int, N = 2
float x {obj.perform(5, 3)};

Declaring templated functions is done in the same manner as templated classes, and using templated functions is done similarly to templated classes: Use the function as if it were a normal function but immediately after the function name add in a comma separated list of substitutions sandwiched within angle brackets.

// declare
template <typename X, typename Y, typename Z, int N>
X perform(Y &var1, Z &var2) {
    return (var1 + var2) * N;
}

// use
float x {perform<float, int, int, 2>(5, 3)};

When the template parameters are for types only (not values), it's possible to leave out substitutions during usage. The compiler will deduce the types from the argument you pass in and substitute them automatically.

// declare
template <typename X, typename Y, typename Z>
X perform(Y &var1, Z &var2) {
    return var1 + var2;
}

// use
float x {perform(5, 3)};  // template arguments omitted, deduced by compiler

It's possible to supply a default substitution for a template parameter by appending it with = followed by the substitution, called default template argument.

template <typename X, typename Y = long, typename Z = long>
X perform(Y &var1, Z &var2) {
    return var1 + var2;
}

Similarly, it's possible to use templates with type aliasing to create shorthand names where only some of the template parameters need to be set, called partial templates.

// declare
template <typename Y, typename Z>
using MyClassPartialTemplate = MyClass<float, Y, Z, 42>;

// use
MyClass<float, int, int, 42> x{}; 
MyClassPartialTemplate<int, int> y{};  // same type as previous line

Normally, C++ code is split into two files: a header file that contains declarations (e.g. function signatures) and a C++ file that contains definitions (e.g. function signatures with their bodies). When accessing C++ code that isn't local, typically only the declarations of that non-local code need to be included. The linker binds those non-local declarations to their definitions when it comes time to build the executable.

Templates work differently from Java generics in that the C++ compiler generates a new code for each unique set of substitutions it sees used (template instantiation). Doing so produces more code than if there was only one copy, but also ensures any performance optimizations unique to that specific set of substitutions. Also, because each usage of a template may result in newly generated code, that usage typically needs access to both the declaration and definition. The simplest way to handle this is to put the entirety of the template (both definition and declaration) into a header, which gets included into the same file as the usage.

Universal References

Universal references allow for collapsing together multiple function overloads where the only differences between overloads are the same parameters being overloaded as both lvalue references and rvalue references. In the following non-templated code, the only difference between the overloads is that one takes a lvalue reference and the other takes a rvalue reference (and moves it).

void test(int & x) {
    if (x % 2 == 0) {
        vector.push_back(x);            // calls push_back(int &x)
    }
}

void test(int && x) {
    if (x % 2 == 0) {
        vector.push_back(std::move(x)); // calls push_back(int &&x)
    }
}

int main() {
    int val {5};
    test(5);    // calls test(int && x)
    test(val);  // calls test(int & x)
    return 0;
}

By templating the code above and forcing the compiler to deduce the parameter type through usage, the compiler can expand out the function overloads on its own.

template<typename T>
void test(T && x) {
    if (x % 2 == 0) {
        vector.push_back(std::forward<T>(x)); // forward to push_back(int &x) OR push_back(int &&x) based on the reference type
    }
}

int main() {
    int val {5};
    test(5);    // calls test(int && x)
    test(val);  // calls test(int & x)
    return 0;
}

In the example above, the parameter x is a universal reference. A universal reference has two ampersands (&&) as if it were a rvalue reference, but since the top-level type is a template parameter (T in this case) it's considered a universal reference. std::forward<T>() is used to maintain the rvalue-ness / lvalue-ness of the argument as it's passed forward into other functions.

For a parameter to be a universal reference, it must follow the pattern NAME && where NAME is the template parameter.

• Adding a const, volatile, or modifying it in any other way will make it go back to becoming a rvalue reference rather a universal reference.
• Nesting NAME as an argument of another type will make it get interpreted as a rvalue reference rather than a universal reference.

template<typename T>
void test(const T&& param) { ... }      // BAD: && means rvalue reference (because of const)

template<typename T>
void test(MyClass<T> && param) { ... }  // BAD: && means rvalue reference (because it's wrapped in a concrete type)

template<typename T>
void test(T&& param) { ... }            // OK: “&&” means universal reference

More examples of universal references in different contexts:

// CONTEXT: Multiple universal references of different types.
template<typename T, typename U>
void test(T && x, U && y) {
    if (x % 2 == 0) {
        vector.push_back(std::forward<U>(y));
    }
}

// CONTEXT: Universal reference of a member function where the class itself is templated.
template<typename UNRELATED_PARAM>
struct MyClass {
    ...
    template<typename T, typename U>
    void test(T && x, U && y) {
        if (x % 2 == 0) {
            vector.push_back(std::forward<U>(y));
        }
    }
    ...
}

Auto Syntax

auto may be used as shorthand for template parameters. If a parameter has a type of auto, that auto assumes the place of a unique template parameter (e.g. T).

void func(auto p);          // template<T> void func(T p);
void func(auto & p);        // template<T> void func(T & p);
void func(auto * p);        // template<T> void func(T * p);
void func(const auto & p);  // template<T> void func(const T & p);
void func(const auto * p);  // template<T> void func(const T * p);
void func(auto && p);       // template<T> void func(T && p);

Likewise, if a return type has a type of auto it assumes the place of a unique template parameter.

auto func(int p);          // template<T> T func(int p);

auto is typically also used for variable declarations. One important aspect of auto for variable declarations to be aware of: Braced initialization / braced-plus-equals initialization produces an std::initializer_list<T> rather than just T.

int x = 5;     // x is int of 5
int x (5);     // x is int of 5
int x {5};     // x is int of 5
int x = {5};   // x is int of 5

// ... vs ...

auto x = 5;    // x is int of 5
auto x (5);    // x is int of 5
auto x {5};    // x is std::initializer_list<int>
auto x = {5};  // x is std::initializer_list<int>

std::vector<int> v ( {1, 2, 3, 4, 5} );

Type Cloning

To automatically derive the type of a variable something to be passed in as a template parameter, use decltype(). This is useful in scenarios where it's difficult or impossible to determine the exact type for a template parameter (e.g. functions, functors, template parameters).

// declare
template <typename FUNC_TYPE>
void perform(FUNC_TYPE * func) {
    func(55);
}

// use
auto my_lambda = [](int x) { std::cout << x; };
perform<decltype(my_lambda)>(my_lambda};

decltype() can take in either an entity (as shown above) or an expression.

// declare
template <typename N>
void perform(N n) {
    std::cout << n;
}

// use
MyClass myClass{}
perform<decltype(myClass.numVar + 1L)>(my_lambda}; // N set to whatever type "myClass.numVar + 1L" evaluates to

int x { 5 };

decltype(x)    // will be an int
decltype((x))  // will be an int &

Type Deduction

C++ templates allow for template parameters to be deduced based on usage.

template<typename T>
bool test(T x) {
    return x % 2 == 0;
}

test(5);     // same as test<int>(5)
test(5ULL);  // same as test<unsigned long long>(5ULL)

The following subsections detail type deduction rules for templates as well as edge cases and workarounds.

Deduction Rules

template<typename T>
bool test(T p) {
    return p % 2 == 0;
}

What the type T gets deduced to depends on what p is specified as and what type gets passed into p as an argument.

int a { 5 };
const int * aPtr { &a };


// Scenario #1: p is just "T" by itself
template<typename T>
bool test1(T p) {
    return *p % 2 == 0;
}
test1(aPtr);

// Scenario #2: p is "T *"
template<typename T>
bool test2(T * p) {
    return *p % 2 == 0;
}
test2(aPtr);

// Scenario #2: p is "const T *"
template<typename T>
bool test3(const T * p) {
    return *p % 2 == 0;
}
test3(aPtr);

The idea with C++'s type deduction is that it tries to do the right thing through pattern matching. In the example above, T was deduced to be the correct type in each of the scenarios.

• In scenario 1, T=const int *.
• In scenario 2, T=const int.
• In scenario 3, T=int.

Pattern matching attempts to deduce template parameter T based on...

• how T is used for function parameter p,
• what expression e is passed as the argument to p.

template<T>
void func(??? p) { // ??? can be T, T&, const T, const T&, ...
    ...
}

func(e); // Given the expression e, func()'s parameter p, what will T be?

For value types, pointer types, lvalue reference types, and rvalue reference types, the rules are as follows:

• When e and p are both values, const / volatile will never transfer over to T because a copy of e is being passed in.
• When e and p are both pointers, const / volatile will transfer over to T if not already set on p.
• When e and p are both references, const / volatile will transfer over to T if not already set on p.
• When e is a value but p is a reference, e gets passed into the function as a reference (const / volatile are maintained on e's reference, see rule where both e and p are references).
• When e is a reference but p is a value, e gets passed into the function as a copy of the value it references (const / volatile are removed from e's copy, see rule where both e and p are values).

For universal references, the rules are more complicated. p gets reinterpreted based on whether e is a lvalue reference or rvalue reference:

• When e is a lvalue reference, both p and T will be interpreted as lvalue reference to the core type.
• When e is a rvalue reference, p is interpreted as an rvalue reference and T is the reference-less version of p.

template<typename T>
void test(T p) {  // T or T& or const T or const T& or ...
    using P = decltype(p);
    using T_ref_removed = std::remove_reference<T>::type;
    using P_ref_removed = std::remove_reference<P>::type;
    using T_ref_and_cv_removed = std::remove_cv<T_ref_removed>::type;
    using P_ref_and_cv_removed = std::remove_cv<P_ref_removed>::type;
    // is_const/is_volatile must have ref removed for test to work: https://en.cppreference.com/w/cpp/types/is_const
    std::cout
        << "p: "
        << (std::is_const<P_ref_removed>::value ? "[const]" : "")
        << (std::is_volatile<P_ref_removed>::value ? "[volatile]" : "")
        << (std::is_lvalue_reference<P>::value ? "[&]" : "")
        << (std::is_rvalue_reference<P>::value ? "[&&]" : "")
        << typeid(P_ref_and_cv_removed).name()
        << "  /  "
        << "T:"
        << (std::is_const<T_ref_removed>::value ? "[const]" : "")
        << (std::is_volatile<T_ref_removed>::value ? "[volatile]" : "")
        << (std::is_lvalue_reference<T>::value ? "[&]" : "")
        << (std::is_rvalue_reference<T>::value ? "[&&]" : "")
        << typeid(T_ref_and_cv_removed).name()
        << std::endl;
}

Type deduction for auto works almost exactly the same as template parameter type deduction. If a parameter type has auto, that auto assumes the place of a unique template parameter (e.g. T). What auto gets deduced to follows the same rules -- it takes into account the expression passed in as the argument for the parameter and how the parameter is specified (e.g. if it's const, a reference, a pointer, etc..).

void func(auto p);          // template<T> void func(T p);
void func(auto & p);        // template<T> void func(T & p);
void func(auto * p);        // template<T> void func(T * p);
void func(const auto & p);  // template<T> void func(const T & p);
void func(const auto * p);  // template<T> void func(const T * p);
void func(auto && p);       // template<T> void func(T && p);
auto func(int p);           // template<T> T func(int p);

This extends to variable declarations that use auto. The rules are essentially the same:

• auto assumes the role of the template parameter
• The full type assumes the role of the parameter (e.g. if it's const, a reference, a pointer, etc..).
• The initializing expression assumes the role of the argument being passed into the parameter.

const auto p = 5;
// Imagine p is a parameter in a function and 5 is the argument being passed into it:
//
// template<T>
// void func(const T p) {
//     ...
// }
// func(5);

The rules are the same even for variables typed as auto &&. When a variable type is auto &&, it's interpreted as a universal reference rather than a rvalue reference. It only becomes a rvalue reference if it's set to a rvalue reference. Otherwise, it's a lvalue reference.

int x { 22 };

auto && p1 = 52;  // p1 is rvalue reference
auto && p2 = x;   // p2 is lvalue reference

Type Cloning Deduction

In certain cases, a variable declaration / return statement needs to replicate the exact type of whatever expression is being assigned to it. This is possible with decltype(auto).

// funcA()'s return type is the exact same as f_ptr()'s return type.
template<typename F>
decltype(auto) funcA(F * f_ptr, int index) {
    return f_ptr(index);
}

// x's type is the exact same as f()'s return type.
decltype(auto) x = f(a1, a2, a3, a4);

This is needed because, with normal type deduction rules, the deduction of T changes based on how the overall type is specified (e.g. (e.g. T, const T, T&, T*, etc..) and the type of the expression that gets assigned to it.

template<typename F, typename T>
T funcA(F * f_ptr, int index) {
    return f_ptr(index);
}

// What does T get deduced as here? Impossible to know because the signature of "f_ptr()" isn't known beforehand. But,
// if "f_ptr(index)" returns a reference, type deduction rules say that T will end up stripping off the reference. So,
// for example, if "f_ptr(index)" returns "MyObject &", this function will end up returning a COPY of that object
// rather than the reference itself.

• If f_ptr() returns a copy and your return type is T, everything is okay.

  template<typename T, typename F>
  T test(F * f_ptr, int index) {
      return f_ptr(index); // f_ptr() returns a COPY and you return a COPY
  }
  

• If f_ptr() returns a reference and your return type is T&, everything is okay.

  template<typename T, typename F>
  T& test(F * f_ptr, int index) {
      return f_ptr(index); // f_ptr() returns a REFERENCE and you return a REFERENCE
  }
  

• If f_ptr() returns a reference but your return type is T, it's inefficient code.

  template<typename T, typename F>
  T& test(F * f_ptr, int index) {
      return f_ptr(index); // f_ptr() returns a REFERENCE and you return a COPY of that reference -- it would have been fine
                           // to return just the reference itself
  }
  

• If f_ptr() returns a copy but your return type is T&, it's faulty code.

  template<typename T, typename F>
  T& test(F * f_ptr, int index) {
      return f_ptr(index); // f_ptr() returns a COPY and you return a REFERENCE to that local copy -- copy is destroyed once
                           // this function exits meaning that the reference will be pointing to junk.
  }
  

If you don't know whether f_ptr() will return a reference or a copy (you just want to mirror back whatever its return type is), use decltype(auto).

template<typename T, typename F>
decltype(auto) test(F * f_ptr, int index) {
    return f_ptr(index); // returns the exact type of f_ptr()
}

// Example from the book
decltype(auto) f1() {
  int x = 0;
  return x;        // decltype(x) is int, so f1 returns int
}

decltype(auto) f2() {
  int x = 0;
  return (x);      // decltype((x)) is int&, so f2 returns int&
}

template<typename T>
auto f1(T x) -> decltype(x + 5) {
    return x + 5;
}

template<typename T>
decltype(x + 5) f1(T x) { // THIS WON'T WORK: x used in decltype() before it's encountered in parameter list
    return x + 5;
}