0.1 What is C++?

If you write code in Python, JavaScript, or Ruby, you are living in a comfortable, highly abstracted world. You declare a variable, push elements to an array, or instantiate an object, and a runtime engine handles all the messy details in the background. It's like checking into a luxury hotel where a butler sweeps up after you. But that comfort has a heavy tax: unpredictability and speed limits. Python will happily let you run code, but it also spends its time counting references and running garbage collection whenever it feels like it, usually right when you need performance the most.

C++ is the exact opposite. It was created by Bjarne Stroustrup with a simple, uncompromising philosophy: Zero overhead. You only pay for what you use. If you want direct access to a hardware address, it's yours. If you want to allocate a chunk of memory on the stack rather than the heap to save nanoseconds, go ahead. C++ compiles straight into native assembly instructions for the host CPU. There is no butler; if you drop a cup, it stays broken, but you get to run at absolute max speed.

This is why C++ runs high performance systems: game engines (like Unreal Engine), database systems (PostgreSQL, MySQL), operating system kernels (Windows, macOS, Linux), and ultra low latency high frequency trading (HFT) infrastructure. When execution time is measured in microseconds and physical memory efficiency matters, C++ is the default choice.

One of Bjarne Stroustrup's famous tenets is: What you don't use, you don't pay for. And further: What you do use, you couldn't hand-code any better.

For example, when we use a C++ compiler optimization flag (like -O3), the compiler generates assembly instructions that are as fast as (or faster than) what a human assembly engineer could write by hand. This allows you to write high level, readable abstractions (like templates, classes, and generic algorithms) without losing a single cycle of CPU execution speed.

To write high performance C++, I want you to start thinking about how code physically fits into your CPU and RAM. Modern CPUs do not read memory one byte at a time. Instead, they read memory in 'words' (typically 4 bytes on 32-bit systems or 8 bytes on 64-bit systems).

Because of this, the compiler performs structure padding to align data variables in memory. If a variable is not aligned to its natural boundary, the CPU has to make two memory accesses instead of one to read it. Let's see what happens to variables behind the scenes in memory layout:

struct Unaligned {
    char a;      // 1 byte
    // 3 bytes of silent padding are added here to align the next integer!
    int b;       // 4 bytes
    char c;      // 1 byte
    // 3 bytes of silent padding are added here to align the entire struct!
};
// sizeof(Unaligned) is 12 bytes, even though the data only sums to 6 bytes!

struct Aligned {
    int b;       // 4 bytes
    char a;      // 1 byte
    char c;      // 1 byte
    // 2 bytes of padding are added at the end to align the struct.
};
// sizeof(Aligned) is 8 bytes! By ordering members correctly, you save memory and cache lines.

I want to teach you C++ from the ground up, but we will not learn ancient C++ habits that belong in museum exhibits. We will focus on clean, modern conventions. We will talk about stack vs. heap memory, compiler optimizations, cache locality, and how the choices you make in your code manifest physically in the computer's memory.

Let's get started by writing, compiling, and running your very first C++ program in the next lesson.