C++ Programming Language Cheat Sheet

Updated 2026-04-28

Next Topic: Clojure Programming Language Cheat Sheet

🧠Study flashcards on this topic209 cards · spaced repetition→

C++ is a high-performance, statically-typed, compiled language that extends C with object-oriented, generic, and functional programming paradigms. It powers systems software, game engines, high-frequency trading platforms, and performance-critical applications where direct hardware control and zero-cost abstractions are essential. The language evolves on a three-year cycle — C++20 introduced modules, ranges, concepts, and coroutines; C++23 stabilized them and added std::mdspan, std::print, flat containers, and std::generator; C++26 — finalized in March 2026 — ships static reflection, contracts, std::execution (Senders/Receivers async model), and hardened memory safety, making it the most impactful release since C++11. The key mental model: C++ gives you full control at every layer, but demands you understand the cost of every operation.

What This Cheat Sheet Covers

This topic spans 29 focused tables and 402 indexed concepts, 209 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Fundamental Data TypesTable 2: Type Qualifiers and ModifiersTable 3: Variable Declaration and InitializationTable 4: OperatorsTable 5: Control Flow StatementsTable 6: FunctionsTable 7: Pointers and ReferencesTable 8: Smart PointersTable 9: Classes and ObjectsTable 10: Inheritance and PolymorphismTable 11: Operator OverloadingTable 12: TemplatesTable 13: Lambdas and ClosuresTable 14: STL ContainersTable 15: STL AlgorithmsTable 16: Range Views and AdaptorsTable 17: IteratorsTable 18: Strings and String UtilitiesTable 19: Concurrency and MultithreadingTable 20: Exception HandlingTable 21: File I/O and StreamsTable 22: Memory ManagementTable 23: Casting OperatorsTable 24: Namespaces and ScopeTable 25: Preprocessor DirectivesTable 26: Modern C++ Features (C++11/14/17/20/23/26)Table 27: AttributesTable 28: Type Traits and MetaprogrammingTable 29: Utility Types

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Fundamental Data Types

C++'s built-in types come with size guarantees that are mostly minimums rather than exact widths, which is why int is "typically" 32-bit and long long is "at least" 64-bit. The richer story here is character types: alongside plain char you get the Unicode-specific char8_t, char16_t, and char32_t, plus utility types like size_t for indexing and nullptr_t for null pointers. C++23 even adds fixed-width floating-point aliases when you need exact bit layouts.

Type	Example	Description
int	`int x = 42;`	• Signed integer, typically 32-bit • most common integer type for general arithmetic.
long long	`long long n = 9223372036854775807LL;`	• Signed integer, at least 64-bit • guaranteed to hold large values across platforms.
float	`float f = 3.14f;`	• Single-precision 32-bit floating-point • lower precision but faster and smaller than double.
double	`double d = 3.14159265359;`	• Double-precision 64-bit floating-point • default for decimal literals and most numerical work.
bool	`bool flag = true;`	• Boolean type holding `true` or `false` • converts to 1 or 0 in integer contexts.
char	`char c = 'A';`	• Single 8-bit character • typically used for ASCII or narrow strings.
wchar_t	`wchar_t wc = L'Ω';`	• Wide character type, size platform-dependent • used for Unicode on Windows or legacy code.
char8_t (C++20)	`char8_t u8c = u8'€';`	• UTF-8 character type • explicitly represents 8-bit UTF-8 code units.
char16_t (C++11)	`char16_t u16 = u'€';`	• UTF-16 character type • holds 16-bit Unicode code units.
char32_t (C++11)	`char32_t u32 = U'😊';`	• UTF-32 character type • holds 32-bit Unicode code points directly.
void	`void func() { }`	• Represents absence of type • used for functions with no return value or generic pointers (`void*`).
size_t	`size_t sz = sizeof(int);`	• Unsigned integer type from `<cstddef>` • result of `sizeof`, guaranteed to hold any array index.
nullptr_t (C++11)	`std::nullptr_t p = nullptr;`	• Type of `nullptr` • distinct from `NULL` or `0`, explicitly represents a null pointer.
Fixed-width floats (C++23)	`std::float32_t f = 1.0f;` `std::float16_t h = 0.5;`	• Optional fixed-width floating-point aliases from `<stdfloat>` • `std::float16_t`, `std::float32_t`, `std::float64_t`, `std::float128_t`, `std::bfloat16_t`.

Table 2: Type Qualifiers and Modifiers

Qualifiers change how a variable can be used or when it's evaluated rather than what it holds. The const-family controls mutability and the increasingly precise constexpr/consteval/constinit trio pushes evaluation toward compile time, while volatile, mutable, and the signed/unsigned modifiers handle the special cases — hardware registers, caches inside const objects, and the choice between negative values and a doubled positive range.

Qualifier	Example	Description
const	`const int x = 10;`	• Declares a variable immutable after initialization • compiler enforces read-only access.

The rest of this section is part of the full cheat sheet

Table 3: Variable Declaration and Initialization

C++ has a famously large menu of ways to initialize a variable, and the distinctions actually matter: brace (uniform) initialization prevents narrowing conversions, auto lets the compiler deduce the type, and decltype preserves references and cv-qualifiers that auto would strip away. This table also covers storage duration — static, extern, thread_local — and the modern conveniences of structured bindings and the C++26 placeholder _.

Technique	Example	Description
Direct initialization	`int x(42);`	• Calls constructor with given arguments • avoids narrowing for fundamental types.

The rest of this section is part of the full cheat sheet

Table 4: Operators

Beyond the arithmetic, comparison, and logical operators you'd expect, C++ exposes a number of operators that reveal its low-level character — sizeof and alignof for memory layout, typeid for runtime type identification, and the scope resolution :: for reaching into namespaces and classes. The standout modern addition is the C++20 spaceship operator <=>, a three-way comparison that can auto-generate all six relational operators from a single line.

Operator	Example	Description
*Arithmetic (+, -, , /, %)**	`int r = (a + b) * c / d;`	• Standard math operators • `%` is modulo (remainder), only valid for integers.

The rest of this section is part of the full cheat sheet

Table 1: Fundamental Data Types

Type	Example	Description
int	`int x = 42;`	• Signed integer, typically 32-bit • most common integer type for general arithmetic.
long long	`long long n = 9223372036854775807LL;`	• Signed integer, at least 64-bit • guaranteed to hold large values across platforms.
float	`float f = 3.14f;`	• Single-precision 32-bit floating-point • lower precision but faster and smaller than double.
double	`double d = 3.14159265359;`	• Double-precision 64-bit floating-point • default for decimal literals and most numerical work.
bool	`bool flag = true;`	• Boolean type holding `true` or `false` • converts to 1 or 0 in integer contexts.
char	`char c = 'A';`	• Single 8-bit character • typically used for ASCII or narrow strings.
wchar_t	`wchar_t wc = L'Ω';`	• Wide character type, size platform-dependent • used for Unicode on Windows or legacy code.
char8_t (C++20)	`char8_t u8c = u8'€';`	• UTF-8 character type • explicitly represents 8-bit UTF-8 code units.
char16_t (C++11)	`char16_t u16 = u'€';`	• UTF-16 character type • holds 16-bit Unicode code units.
char32_t (C++11)	`char32_t u32 = U'😊';`	• UTF-32 character type • holds 32-bit Unicode code points directly.
void	`void func() { }`	• Represents absence of type • used for functions with no return value or generic pointers (`void*`).
size_t	`size_t sz = sizeof(int);`	• Unsigned integer type from `<cstddef>` • result of `sizeof`, guaranteed to hold any array index.
nullptr_t (C++11)	`std::nullptr_t p = nullptr;`	• Type of `nullptr` • distinct from `NULL` or `0`, explicitly represents a null pointer.
Fixed-width floats (C++23)	`std::float32_t f = 1.0f;` `std::float16_t h = 0.5;`	• Optional fixed-width floating-point aliases from `<stdfloat>` • `std::float16_t`, `std::float32_t`, `std::float64_t`, `std::float128_t`, `std::bfloat16_t`.

Table 2: Type Qualifiers and Modifiers

Qualifier	Example	Description
const	`const int x = 10;`	• Declares a variable immutable after initialization • compiler enforces read-only access.

Table 3: Variable Declaration and Initialization

Technique	Example	Description
Direct initialization	`int x(42);`	• Calls constructor with given arguments • avoids narrowing for fundamental types.

Table 4: Operators

Operator	Example	Description
*Arithmetic (+, -, , /, %)**	`int r = (a + b) * c / d;`	• Standard math operators • `%` is modulo (remainder), only valid for integers.