1.3 The Compilation Process

1.1 What is C++?

C++ is a general-purpose, compiled programming language created by Bjarne Stroustrup in 1979 at Bell Labs as an extension of the C programming language (originally dubbed "C with Classes"). It kept everything that made C fast — direct control over memory and bare-metal hardware access — and added Object-Oriented Programming (OOP) on top, so developers could organize large, complex software systems around "objects" (classes, inheritance, polymorphism) instead of just loose procedural functions.

Because C++ compiles straight down to native machine code, instead of running inside a virtual machine like Java or an interpreter like Python, it is the undisputed language of choice wherever raw computational speed, determinism, and predictable zero-overhead performance matter: game engines (Unreal Engine), operating systems (Windows, macOS kernel, Linux drivers), web browser rendering engines (Chromium/V8), embedded systems, robotics, and ultra-low-latency High-Frequency Trading (HFT) platforms.

Analogy (from the Guide):

Think of C as a bicycle — light, fast, fully under your manual control, but you have to do everything yourself. C++ is that same bicycle with an optional car body bolted on: you still have full manual control when you want it, but you also get comfortable, structured, high-level tools (classes, the Standard Template Library, smart pointers) for building big, complex machines.

The Three Pillars of C++

Compiled language: Turned directly into CPU machine code before running, which makes it blisteringly fast.
Statically typed: Every variable's type is fixed and verified at compile-time before the program ever runs.
Multi-paradigm: Seamlessly supports procedural, object-oriented, functional, and generic (template metaprogramming) in one unified language.

Figure 1.1 — C++ builds Object-Oriented power on top of C's raw speed

1.2 Structure of a C++ Program

Every C++ program, no matter how large, is built from the same handful of moving parts. Learning to recognize each one removes the "why do I have to type this every single time?" confusion that trips up beginners.

Minimal C++ Program Skeleton

#include <iostream>  // 1. Preprocessor directive
using namespace std; // 2. Namespace declaration

int main() {         // 3. Program entry point
    cout << "Hello, World!"; // 4. Statement: print to console
    return 0;        // 5. Exit status returned to OS
}

Anatomy Breakdown

#include <iostream>: Pulls in ready-made code from another file — here, the input/output stream tools needed for console communication.
using namespace std;: Allows you to write cout instead of prefixing the standard namespace every time (std::cout).
int main(): The single door every C++ program walks through first; the operating system calls it automatically the moment your program starts, and nothing else in your file runs until execution reaches it.
cout << ...: The standard character output stream (pronounced "see-out"). The insertion operator (<<) sends data into the stream.
return 0;: The program's way of telling the operating system "I finished successfully" — a non-zero return value (e.g. return 1;) is the traditional Unix/Windows signal that an error occurred.

Figure 1.2 — The anatomy of a minimal C++ program

Unlike Python, C++ code never runs directly. It must first be translated, in distinct stages, into native machine instructions the processor can execute — and understanding those stages is exactly what makes errors like "undefined reference" or "linker error" click instead of feeling random.

The Four Build Pipeline Stages

Preprocessor: Runs first and handles everything starting with # (like #include and #define), literally copy-pasting included header files and expanding macro definitions into pure C++ text.
Compiler: Translates your preprocessed C++ source into assembly language instructions and verifies your code for syntax correctness and strict type compatibility.
Assembler: Converts that assembly code into binary object files (.o or .obj) containing raw machine instructions.
Linker: Stitches all your separate object files together with the C++ Standard Library and any third-party compiled binaries, resolving function references to produce a single runnable executable (e.g. .exe or ELF binary).

Figure 1.3 — How a .cpp file becomes a runnable program

Common Pitfall (from the Guide):

A compile-time error means the compiler couldn't parse your syntax (a missing semicolon, an unmatched bracket, or a type mismatch). A link-time error means your syntax was fine, but you referenced something — a function, a variable — that was declared in a header but never actually defined in any compiled .cpp or library. Beginners often try to "fix" a linker error by endlessly editing syntax, which never works.

1.4 Variables & Data Types

A variable is a named box in memory that holds a value. Before you can use one in C++ you must declare its type, which tells the compiler exactly how many bytes to reserve for it and how to interpret the binary bits stored there — an int and a float can occupy the exact same 4 bytes of memory, but represent completely different things.

C++ organizes data types into three major families:

Fundamental types: Built directly into the language hardware instructions (int, float, double, char, bool, void).
Derived types: Assembled from other types (arrays, pointers, references, functions).
User-defined types: Types that you design yourself (struct, class, union, enum).

int age = 21;          // 4 bytes: whole number
double price = 9.99;   // 8 bytes: high-precision decimal number
char grade = 'A';      // 1 byte: single ASCII character
bool passed = true;    // 1 byte: boolean true (1) / false (0)

Figure 1.4 — How C++'s data types are organized

Key Insights (from the Guide):

int stores whole numbers, float / double store decimals, char stores one character, bool stores true/false.
Choosing the right type matters for memory and precision: double uses 8 bytes of memory compared to float's 4 bytes, but provides 15–17 decimal digits of precision instead of float's 7 digits.

1.5 Operators

Operators are symbols that perform an operation on one or more values, called operands. C++ groups them by their semantic purpose:

Arithmetic operators (+ - * / %): Perform basic mathematics.
Relational operators (== != < > <= >=): Compare two values and produce a boolean (true or false).
Logical operators (&& || !): Combine or negate boolean conditions.
Assignment operators (= += -= *= /=): Store or update the value held in a variable.

int a = 10, b = 3;
int sum = a + b;           // 13 (arithmetic)
bool isBigger = a > b;     // true (relational)
bool both = (a>5) && (b>0); // true (logical)
a += 5;                    // a = a + 5 -> 15 (assignment)