Search⌘ K
AI Features
Home
Courses
Master Modern C++

Introduction to C++ and its Compilation Model

Explore how C++ transforms source code into machine-executable programs through preprocessing, compilation, and linking. Understand the difference between compiled and interpreted languages, and write a minimal program that outputs text to the console. This lesson lays the foundation for mastering C++ program structure and its compilation model.

We'll cover the following...

C++ is a general-purpose programming language designed for building efficient and high-performance softwares. It is widely used in performance-critical systems including operating systems, game engines rendering photorealistic graphics, and large-scale applications.

One of its defining characteristics is the level of control it provides over how programs interact with hardware. This control comes from how C++ applications are built and executed. Understanding this process is essential, as it influences how we structure, compile, and run every C++ program we write.

Compiled vs. interpreted languages

To understand C++, we must first know how it differs from other languages like Python or JavaScript. Programming languages generally fall into two categories based on how they are executed: compiled and interpreted.

In interpreted languages (like Python or JavaScript), an interpreter reads your source code line by line while the program is running. It translates and executes instructions on the fly. This is flexible, but it takes time; like a translator listening to a speech and translating it sentence by sentence to an audience.

Whereas, C++ is a compiled language. Before a C++ program runs, it must go through a complete translation process called compilation. We feed our source code into a tool called compiler, which translates the entire program into machine code (binary) all at once. The result is a standalone executable file that runs directly on the hardware.

Because the translation happens before the program runs, C++ is incredibly fast. The computer doesn't have to interpret what your code means while it’s running; it simply executes the raw machine instructions.

The C++ build process

The journey from a text file to an executable involves three distinct steps. Understanding this flow helps us identify and resolve errors when they arise.

  1. Preprocessing: Before the compiler starts understanding our code, the preprocessor runs. It doesn't care about logic. It only looks at lines that start with the # symbol, called preprocessor directives, e.g., #include, etc. When the preprocessor sees this, it copies the contents of another file and pastes it into our program. You can think of preprocessing as preparing the code; gathering files, replacing shortcuts, and removing unnecessary parts; so the compiler receives one complete, ready-to-translate file.

  2. Compilation: The compiler translates the preprocessed C++ code into an intermediate format: an object file, typically ending in .o or .obj. This file contains machine code, but it isn't a complete program yet. If we make errors, the compiler stops here and reports them.

  3. Linking: A typical C++ program consists of multiple source files and external libraries. The linker combines all the object files into a single executable. It resolves references, ensuring that if we call a function defined in another file, the program knows where to find it.

Headers and source files

As programs grow, we cannot keep all our code in one file. C++ uses two types of files to manage complexity:

  • Source files (.cpp): These contain the actual implementation logic, i.e., the functions and variables that do the work.

  • Header files (.h or .hpp): These define interfaces. They tell the compiler what functions and types exist, without necessarily providing the full implementation logic.

By separating declarations (headers) from implementations (source), C++ allows us to compile files independently and link them later, thereby speeding up builds for large projects.

A first minimal C++ program

Let's start with the smallest useful C++ program: one that prints something to the console. We will not break down every keyword yet; we just want to see what a C++ “unit” of code looks like.

Here is a minimal program that prints a line of text:

C++ 23
#include <iostream>
int main() {
    std::cout << "Hello, World!";
    return 0;
}

  • Line 1: #include <iostream> allows the program to use basic input and output features, such as printing text to the screen. You’ll see this header in almost every beginner C++ program.

  • Line 3: int main() defines the starting point of the program. When the program runs, execution begins here. The code inside the curly braces {} makes up the body of the main function.

  • Line 4: This line prints the text “Hello, World!” to the screen.std::cout is used for output in C++. Without including <iostream>, this line would not work.

  • Line 5: return 0; ends the program and indicates that it finished successfully.

  • Line 6: The closing brace } marks the end of the main function.

Do not worry if #include, std::cout, or even the details of main feel unfamiliar. We will cover each of these in later lessons.

The Standard Library

In the example above, we used std::cout. The prefix std:: indicates that cout belongs to the Standard Library namespaceA namespace in C++ is a declarative region that provides a scope to the identifiers (such as names of types, functions, and variables) within it. The C++ Standard Library is a massive collection of pre-written, optimized code that provides essential functionality like input/output, math operations, and data containers. We use it to avoid reinventing the wheel for common tasks.

We have successfully taken our first step. We now understand that C++ relies on a compiler to turn human-readable code into high-performance machine instructions. We also wrote a minimal program that acts as the skeleton for every application we will build.