C++ Handbook

C++ is a compiled, statically typed language that gives you direct control over memory and hardware while still offering high-level tools: classes, templates, a large standard library and automatic cleanup through destructors. That combination — fast like C, expressive like a modern language — is why it still runs the software where speed and predictability matter most.

Bjarne Stroustrup started it in 1979 as "C with Classes" at Bell Labs; it was renamed C++ in 1983 and has been an ISO standard since 1998. The language now evolves on a three-year cycle, and this handbook teaches C++20, with notes where C++17 (still common in industry) differs.

C++ source code is plain text. A compiler turns it into a native executable for your machine. There are three major compilers, all free: GCC (the g++ command, standard on Linux), Clang (clang++, standard on macOS) and MSVC (Microsoft's, used by Visual Studio on Windows). Any of them runs every example in this handbook.

macOS

# Installs Apple clang, make, git and the SDK headers (no full Xcode needed)
xcode-select --install

# Check it worked — on macOS "g++" is an alias for clang
clang++ --version
g++ --version

On a Mac, g++, c++ and clang++ all run Apple clang. If you specifically want GCC, brew install gcc installs it as g++-14 (the number is the version).

Windows

# Option A — MSVC: install "Visual Studio Community" and tick
#   "Desktop development with C++". Then open
#   "Developer Command Prompt for VS" and compile with:
cl /std:c++20 /EHsc main.cpp

# Option B — GCC via MSYS2 (gives you g++ in a normal terminal)
winget install MSYS2.MSYS2
# then, inside the "MSYS2 UCRT64" shell:
pacman -S mingw-w64-ucrt-x86_64-gcc
g++ --version

MSVC is what most Windows game studios use. MSYS2 gives you the same g++ commands this handbook shows. If you use WSL (Windows Subsystem for Linux), follow the Linux steps inside it.

Linux

# Debian / Ubuntu
sudo apt update && sudo apt install build-essential

# Fedora
sudo dnf install gcc-c++

# Arch
sudo pacman -S gcc

g++ --version

build-essential installs g++, make and the C/C++ standard library headers. GCC 11 or newer supports everything in this handbook with -std=c++20.

Create a folder, save the program below as main.cpp, then compile and run it. Every example in this handbook is a complete program like this one, and the output shown beneath it is exactly what it prints.

#include <iostream>

int main() {
    std::cout << "Hello, C++!\n";
    std::cout << "2 + 3 = " << 2 + 3 << '\n';
    return 0;
}

Hello, C++!
2 + 3 = 5

g++ -std=c++20 main.cpp -o main   # compile: main.cpp -> an executable named "main"
./main                              # run it (on Windows: main.exe)

-std=c++20 picks the language version; -o main names the output file. Without -o you get a.out (a.exe on Windows).

Unlike Python or JavaScript, a C++ program is translated to machine code before it runs. The single g++ command you typed actually runs four separate stages, and knowing them tells you what kind of error you are looking at.

1. 1
   1. Preprocess

   Handles every line starting with #: #include pastes a header file's text in, #define does text substitution. The result is one big "translation unit". See it with g++ -E main.cpp.

2. 2
   2. Compile

   Checks syntax and types, then turns the translation unit into assembly for your CPU. Syntax and type errors happen here, reported as main.cpp:LINE:COL: error:.

3. 3
   3. Assemble

   Turns the assembly into an object file (main.o) — machine code with holes where calls to other files' functions go. g++ -c main.cpp stops here.

4. 4
   4. Link

   The linker joins your object files and the standard library into one executable, filling in every hole. If a function was declared but never defined anywhere, this stage fails, with an "undefined symbol" / "undefined reference" error.

# Real projects have many .cpp files. Compile each to an object file…
g++ -std=c++20 -c main.cpp -o main.o
g++ -std=c++20 -c math.cpp -o math.o
# …then link them together:
g++ main.o math.o -o app

# Or all in one command (it still runs the four stages per file):
g++ -std=c++20 main.cpp math.cpp -o app

Splitting compile and link is what build tools like CMake and make do for you: only the files you changed get recompiled, then everything is re-linked. Module 12 covers CMake.

#include <iostream>

int add(int a, int b);   // declared: "this exists somewhere"

int main() {
    std::cout << add(2, 3) << '\n';
}

Undefined symbols for architecture arm64:
  "add(int, int)", referenced from:
      _main in main-19c9d3.o
ld: symbol(s) not found for architecture arm64
clang++: error: linker command failed with exit code 1 (use -v to see invocation)

#include <iostream>

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

int main() {
    std::cout << add(2, 3) << '\n';
}

Compiler

The program that translates C++ source into machine code: g++ (GCC), clang++ (Clang) or cl (MSVC).

Translation unit

One .cpp file after the preprocessor has pasted in all its #included headers. The compiler works on one at a time.

Object file

The compiled machine code for one translation unit (.o or .obj), not yet runnable.

Linker

Combines object files and libraries into one executable and resolves calls between them.

Standard (C++20)

The ISO version of the language. Pick it with -std=c++20 (GCC/Clang) or /std:c++20 (MSVC).

Every program in this handbook follows the same skeleton. Here it is with each part labelled in comments. // starts a comment that runs to the end of the line; /* … */ can span several lines. Comments are removed before compiling and cost nothing at runtime.

// 1. Includes: pull in the declarations you need
#include <iostream>
#include <string>

/* 2. Your own functions go above main
      (or are declared above it and defined later). */
std::string greet(const std::string& name) {
    return "Hello, " + name;
}

// 3. main: where the program starts
int main() {
    std::string who = "world";      // a variable with a type
    std::cout << greet(who) << '\n';
    return 0;                       // 0 = success
}

Hello, world

#include <iostream>

int main() {
    cout << "Hello\n";
}

main.cpp:4:5: error: use of undeclared identifier 'cout'; did you mean 'std::cout'?
    4 |     cout << "Hello\n";
      |     ^~~~
      |     std::cout

#include <iostream>

int main() {
    std::cout << "Hello\n";
}

The compiler can catch many bugs for you, but only if you ask. These flags work with both g++ and clang++; the MSVC equivalents are in the last column.

# A good everyday "learning" build command:
g++ -std=c++20 -Wall -Wextra -g -fsanitize=address,undefined main.cpp -o main

Slower to run, but most beginner bugs become a clear message instead of a silent wrong answer. Module 06 shows what the sanitizer reports look like.

#include <vector>

int main() {
    std::vector<int> v{1, 2, 3};
    for (int i = 0; i < v.size(); i++) {
    }
}

main.cpp:5:23: warning: comparison of integers of different signs: 'int' and 'size_type' (aka 'unsigned long') [-Wsign-compare]
    5 |     for (int i = 0; i < v.size(); i++) {
      |                     ~ ^ ~~~~~~~~

#include <vector>

int main() {
    std::vector<int> v{1, 2, 3};
    for (std::size_t i = 0; i < v.size(); i++) {
    }
}

C++ cannot run inside a web page, so this handbook does the next best thing: every example was compiled with a real C++20 compiler and run, and the output printed under it is exactly what came out. A script re-checks every example whenever the handbook changes, so the page never drifts from what the code really does.

• Copy, compile, change. Paste an example into main.cpp, build it with g++ -std=c++20 main.cpp -o main, then do the "Your turn" task. Reading code teaches you little; changing it and predicting the result teaches you a lot.
• Error cards show real compiler and sanitizer messages, copied from actually building the code, with why it happened and the fix. Learn to read the first line of an error: file:line:column: error: message.
• Traces step through a program line by line, showing variables and output as they change.
• The floating board collects every term from the glossary blocks, so you can look up "RAII" or "dangling pointer" without losing your place.
• The certification exam at the end: 25 questions drawn from all modules, pass with 70% to earn a free certificate.