Standard C++ 20
Pocket Guide

Goldaniatech image

C++ Guide Overview

My C++ guide is focused on the most essential concepts of Standard C++20, covering core syntax, data types, programming paradigms, and the C++ Standard Library (including the Standard Template Library or STL).

As a 3D Software Developer and Computer Science Instructor working on a daily basis with Unreal Engine 5, either for my game Goldaniatech or for teaching purposes, my C++ knowledge is mostly tied to Unreal, and more specifically to the Unreal C++ language, which I use extensively. Since Unreal Engine 5 currently supports C++20, I mostly ignore C++23 and C++26 features outside of a few exceptions.

Guide Usage

I’ve written this C++ pocket guide as a lightweight overview designed strictly for quick revision. It’s meant to serve as a condensed technical and philosophical reference rather than a full-fledged course or syllabus.

Disclaimer

As an independent Computer Science instructor, I provide this guide as a standalone educational resource. It is not affiliated with, endorsed by, or associated with any academic institution or certification provider.

Benchmark Demo on Epic

Skills Overview

Introduction

Programming Languages Classification: High-Level • Low-Level
Toolchain: Compiler • Linker • Debugger
Key Elements: Source File (.cpp, .h) • Object File (.o, .obj) • Executable
Standard Library

Introduction

Languages Overview

Around 7,000 natural languages are spoken worldwide, while thousands of programming languages have been created since the 1950s.

In both cases, only a few languages are widely used. Among the most popular programming languages are C, C++, C#, Java, Python, JavaScript, and PHP.

Standardized Languages

Dominant natural languages and programming languages are usually standardized. Programming languages evolve through standardized versions that introduce new features.

For example, C++26 adds reflection and hazard pointers, while Python 3.14 introduces template strings (t-strings).

Ranks & Categories

Several programming language rankings exist, such as the TIOBE Index or the IEEE Spectrum ranking.

Programming languages are also often categorized based on their level of abstraction: low-level, mid-level, and high-level languages. Low-level languages are closer to machine code and hardware and generally require more technical knowledge, whereas high-level languages are closer to natural human language (English) and are usually easier to read and write.

Learning Programming Languages

Truly mastering a programming language involves understanding its entire ecosystem (frameworks, libraries, game engines, tools, etc.), not just learning its syntax and standard library.
Learning the basics of a new language can take days or weeks, but learning its ecosystem and becoming productive typically requires months, if not years.
Realistically, a person can typically master only a very limited number of languages in either category. Deep expertise in a few languages generally outweighs basic knowledge of many languages.

Development Tool Categories

No-Code Tools/Platforms: Wix, RPG Maker (without scripts).
Educational Languages: Scratch (primarily used for learning and education).
Textual Languages: C++, Python…
Visual Languages: Unreal Engine Blueprints, Blender Geometry Nodes…

Programming Languages Translation

Every existing programming language is ultimately translated into machine code that a CPU can execute.

Machine code consists of binary instructions (0s and 1s), although it can be represented using more readable notations such as hexadecimal.
Assembly languages are architecture-specific and use an assembler to translate source code into machine code. For example, MIPS Assembly for the PlayStation 1 or 65816 Assembly for the Super Nintendo.
- Each assembly language is tied to a specific CPU architecture. For example, the PlayStation 1’s MIPS Assembly was not identical to the Nintendo 64’s MIPS Assembly because the two systems used different versions of the MIPS architecture
Compiled languages have their source code entirely translated into machine code before execution. This process produces a binary (or executable) that targets a specific platform and CPU architecture, such as Windows x64, Linux x64, or macOS ARM64. Examples include C, C++, and Rust.
- Most compiled languages use Ahead-of-Time (AOT) compilation, meaning that the translation to machine code occurs before the program is run
Interpreted languages execute code through an interpreter, a virtual machine, or a runtime environment rather than producing a standalone native executable before execution. Examples include Python, JavaScript, Unreal Blueprints, and Verse.
- Some languages use pure interpretation, where instructions are executed directly by an interpreter.
- Other languages use hybrid interpretation with a virtual machine, where the source code is first translated into an intermediate representation called bytecode, which is then executed by a virtual machine.
- Just-In-Time (JIT) compilation translates bytecode into machine code during program execution, combining aspects of both interpretation and compilation.
Transpiled languages have their source code translated into another programming language at a similar level of abstraction. The most well-known example is TypeScript, which is transpiled into JavaScript.

⚠️ In practice, the distinction between “compiled” and “interpreted” languages is not absolute. Many modern languages combine multiple approaches. For example, C# is compiled into Intermediate Language (IL), which is then executed by the .NET runtime and may be JIT-compiled into native machine code.

C++ Translation

Technically, the C++ 23 standard (section 5.2) defines 9 phases of translation that occur between the source code and the final executable. However, we usually cover 4 major steps for the C++ translation process:
- Preprocessing: directives such as #include and #define are processed before the compiler analyzes the program.
- Compilation: the compiler checks the program and translates the source code into a specific assembly language for the target machine.
- Assembly: the assembler converts the generated assembly code into object files (.o or .obj).
- Linking: the linker combines object files and libraries into the final executable.

C History

C was created primarily by Dennis Ritchie at Bell Labs around 1972 (more precisely between 1969 and 1973), with contributions from Ken Thompson and based on his B language.
C was closely tied to the early development of the Unix operating system.
One of the main goals of this language was portability: allowing programs to run on multiple machines with minimal modifications, while still providing low-level access to hardware (Ritchie 1993).
C is often called the “mother of programming languages” because it established the foundation for many modern languages, including C++, Java, and Python.
C language history played a significant role in game development during the mid 1990s and early 2000s (5th generation of consoles), often alongside assembly languages for optimizing performance!

C++ History

Bjarne Stroustrup began developing C++ in 1979 and released the first official version in 1985. Initially called C with Classes, it added object-oriented features to C and was strongly inspired by the Simula language.
Templates were introduced during the 1990s, for C++ 98. This also led to the creation of the Standard Template Library (STL) by Alexander Stepanov & Meng Lee
Modern C++ is usually what we refer to for the language’s evolution since C++ 11 standard, which introduced significant enhancements.

Getting Started!

To start writing C++ code, you need either a Text Editor (along with a compiler) or just an IDE.

Integrated Development Environments (IDE) like Visual Studio 2026 are full-fledged tools that integrates and manages the entire toolchain (compilers, linkers, debuggers).
Text Editors such as Visual Studio Code are lightweight, modular tools to write code. They usually require external tools such as a compiler (Clang or GCC) for C++ for translating the code.

Basic C++ Program

Every C++ program needs a mandatory entry-point: the main() function.
#include is a preprocessor directive

#include <iostream> 
#include <string>

int main()
{
    std::string name; 

    std::cout << "Hello!\nWhat's your name?" << std::endl;
    std::getline(std::cin, name); 
    std::cout << "Hello, " << name << "!" << std::endl; 

    return 0;   // Program ends successfully
}

Most C++ programs are typically split across multiple files: headers and source files.
Header files (.h, .hpp) usually contain declarations or definition for classes, functions, constants, etc.
source files (.cpp) contain implementations of the header’s definitions.
A header guard prevents a header file from being included multiple times during compilation, which would otherwise cause redefinition errors.
The classic header-based model can get messy on large projects, which is one of the reasons C++20 introduced modules (which I don’t cover in my guide).

// Header Guard (Standard C/C++ Method)
#ifndef INVENTORY_H
#define INVENTORY_H
 
class Inventory { /* ... */ };
 
#endif // INVENTORY_H

// Alternative Modern Method (widely supported)
#pragma once
 
class Inventory { /* ... */ };

Conventions

Conventions are guidelines for naming, formatting, and structuring code (variables, functions, classes, etc.).
The main objective of conventions is for writing clean, consistent, and maintainable C++ code
Unlike Python’s PEP 8, C++ had no single official standard until recently.
The C++ Core Guidelines, written by Bjarne Stroustrup and Herb Sutter, give useful recommendations.
Still, most companies have established conventions to learn.

Fundamental Data Types & Variables

Variables are containers storing data in memory. Every variable value has a type (number, text, etc.) determining what kind of data it can hold and how much memory it uses.
Fundamental or Primitive data types are basic building blocks for storing values like integers, floating-point numbers, characters, and booleans.
C++ is designed with performance and low-level control, especially for integers and floating-point numbers, unlike higher-level languages like Python or C#
Choosing the appropriate data type is important because it affects memory consumption, performance, precision, and the range of values that can be stored.

#include <cstdint> 
#include <limits> 

void ExampleDataTypes() 
{
    // Integers
    int PlayerHealth = 88;
    unsigned int KeyCount = 5;
    short PlayerAmmo = 850;
    unsigned short ManaPoints = 340;
    long BossHealth = 99999;
    long long WorldPopulation = 7500000000;

    // Fixed-width Integers
    uint8_t TeamSize = 255;
    int16_t Temperature = -15;
    uint32_t PlayerID = 304;

    // Floating-Point Numbers
    float CameraDistance = 340.343f;
    float PlayerSpeed = 10.5f;
    double TargetDistance = 5249.80665;
    long double Pi = 3.141592L;

    // Characters
    char PlayerGrade = 'B';
    unsigned char Opacity = 255;
    signed char DamageModifier = -10;

    // Booleans
    bool IsDriving = true;
    bool CanJump = false;

    // Type Inference
    auto Score = 100;
    auto Speed = 10.5f;
    auto PlayerLetter = 'A';
}

Integers

Integers store whole numbers. They vary in size (bit-width) and signage (signed or unsigned), and number.
By default in Microsoft Visual C++ (MSVC), most integer types are signed. Thus, int is equivalent to signed int.
The unsigned keyword explicitly restricts a type to absolute values only (non-negative or only positive), doubling its positive range.
The size and range of these types vary depending on your system and compiler. A long is 32-bit on many platforms (Windows MSVC), but 64-bit on some (Linux GCC).
- Data type range for the MSVC compiler can be checked at https://learn.microsoft.com/en-us/cpp/cpp/data-type-ranges?view=msvc-170
In general, choosing the wrong type for your data can lead to bugs, such as overflow, truncation, or loss of precision
In most cases, it’s better to use signed integers by default. Mixing signed and unsigned types can trigger implicit conversions that may change the result of arithmetic operations and comparisons.
The <cstdint> header can use types like int8_t, uint16_t, int32_t or else, for exact sizes.
To check exact limits for your system, use the <limits> header from the C++ Standard Library.

Floating-Point Numbers

Floating-point types store real numbers. Unlike integer types, they can represent values with a fractional part, such as 5.25 or 0.348, as well as whole numbers like 5.0 and 250.0.
They’re essential for calculations requiring precision, such as physics simulations.
Floating-point numbers cannot represent every decimal value exactly. This can lead to small rounding errors during calculations
The size, precision, and range of long double vary by platform and compiler. On MSVC, it is usually identical to double, while GCC and Clang may provide additional precision.

Booleans

Booleans are the simplest data type in C++, designed to represent two states: true or false. They’re commonly used for conditions, flags, and decision-making.
Note that true and false keywords in C++ are stored internally as numbers: true is stored as 1 and false as 0.

Characters

Characters are represented by the char type and its variants. They are used to store a single character, such as a letter (‘A’), digit (‘5’), or symbol (‘!’).
A char typically occupies 1 byte of memory and stores its value using a character encoding such as ASCII or Unicode.
C++ also provides character type variants such as signed char, unsigned char, wchar_t, char8_t, char16_t, and char32_t for specific use cases and character encodings.
Use single quotes for character literals (‘A’, ‘5’, ‘!’). Double quotes create string literals (“A”, “Hello”), which are stored as const char[] in standard C++.
Some characters cannot be typed directly and are represented using escape sequences, which begin with a backslash (\). A newline is \n and a horizontal tab is \t

Recommended Resources

Books

Lospinoso, Josh. 2019. C++ Crash Course: A Fast-Paced Introduction. San Francisco: No Starch Press.
Shvets, Alexander. 2018. Dive Into Design Patterns. Refactoring.Guru.
Stroustrup, Bjarne. 2022. A Tour of C++. 3rd ed. Addison-Wesley Professional Computing Series. Boston: Addison-Wesley.
Stroustrup, Bjarne. 2024. Programming: Principles and Practice Using C++. 3rd ed. Boston: Addison-Wesley.

Articles

Refactoring Guru. Design Patterns
Ritchie, Dennis MacAlistair. 1993. The development of the C language.
https://doi.org/10.1145/155360.155580.
Stroustrup & Sutter. C++ Core Guidelines