Compilation and execution process in C++ - Deep Dive

Overview - Compilation and execution process

What is it?

The compilation and execution process is how a C++ program is turned from human-readable code into a running program on your computer. It involves several steps: writing code, compiling it into machine language, linking pieces together, and finally running the program. Each step transforms the code closer to something the computer understands and can execute.

Why it matters

Without this process, your computer would not understand the instructions you write in C++. The compilation and execution process solves the problem of translating human ideas into machine actions. Without it, programming would be limited to only what machines can understand directly, making software development much harder and slower.

Where it fits

Before learning this, you should know basic C++ syntax and how to write simple programs. After understanding this process, you can learn about debugging, optimization, and advanced build tools that improve how programs are created and run.

Mental Model

Core Idea

Compilation and execution is a step-by-step transformation turning human code into machine instructions that the computer can run.

Think of it like...

It's like writing a recipe in your language, then translating it into a language the chef understands, gathering all ingredients, and finally cooking the dish.

Source Code (human-readable) ──► Compiler ──► Object Files (machine code) ──► Linker ──► Executable Program ──► Operating System ──► Runs on Hardware

Build-Up - 7 Steps

1

Foundation

What is source code and compilation

Concept: Introduces source code and the role of the compiler.

Source code is the text you write in C++ using words and symbols. The compiler reads this text and translates it into machine code, which is a language the computer's processor understands. This translation is necessary because computers cannot run source code directly.

Result

You get machine code files that the computer can understand but are not yet a complete program.

Understanding that source code is just text and needs translation is the first step to grasping how programs run.

2

Foundation

Role of the linker in program building

Concept: Explains how separate machine code pieces are combined.

After compiling, you have object files that contain machine code but may refer to other parts of the program. The linker combines these object files and libraries into one executable file. It resolves references so the program knows where to find all functions and data.

Result

A single executable file that can be run by the operating system.

Knowing the linker’s job clarifies why programs can be split into multiple files and still work together.

3

Intermediate

From executable to running program

Concept: Describes how the operating system runs the executable.

When you run the executable, the operating system loads it into memory, sets up the environment, and starts executing instructions from the program's entry point (usually main()). The OS manages resources like memory and CPU time during execution.

Result

Your program starts running and performing the tasks you programmed.

Understanding the OS role helps explain why programs need to be properly linked and formatted.

4

Intermediate

Compilation stages inside the compiler

🤔Before reading on: do you think the compiler translates code in one step or multiple steps? Commit to your answer.

Concept: Breaks down the compiler’s internal steps: preprocessing, compiling, assembling.

The compiler first preprocesses the code, handling directives like #include and #define. Then it compiles the preprocessed code into assembly language. Finally, an assembler converts assembly into machine code (object files). Each stage transforms the code closer to machine instructions.

Result

A clear understanding that compilation is a multi-step process, not just one translation.

Knowing these stages helps you understand how errors and optimizations happen at different points.

5

Intermediate

Static vs dynamic linking explained

🤔Before reading on: do you think linking always happens before running the program? Commit to your answer.

Concept: Introduces two ways linking can happen: before or during execution.

Static linking combines all code into one executable before running. Dynamic linking leaves some code in shared libraries loaded at runtime. Dynamic linking saves space and allows updates without recompiling the whole program.

Result

You understand why some programs depend on external libraries loaded when they run.

Knowing linking types explains why some programs need extra files to run and how updates can be easier.

6

Advanced

How compiler optimizations affect execution

🤔Before reading on: do you think compiler optimizations change what your program does or just how fast it runs? Commit to your answer.

Concept: Explains how compilers improve performance without changing program behavior.

Compilers can rearrange, simplify, or remove code to make programs run faster or use less memory. These optimizations happen during compilation but must keep the program’s output the same. Sometimes, optimizations can expose bugs or change timing, which is important to understand.

Result

You see why compiler flags affect program speed and behavior subtly.

Understanding optimizations helps you write code that works well with the compiler and debug tricky issues.

7

Expert

Linker symbol resolution and surprises

🤔Before reading on: do you think the linker always picks the first function it finds or can it choose differently? Commit to your answer.

Concept: Deep dive into how the linker resolves symbols and handles conflicts.

The linker matches function and variable names (symbols) across object files. If multiple definitions exist, it follows rules to pick one or report errors. Linkers also handle weak symbols and symbol visibility, which can cause unexpected behavior if misunderstood.

Result

You gain insight into subtle bugs caused by symbol conflicts or missing symbols.

Knowing linker internals prevents hard-to-find bugs and helps manage large projects with many files.

Under the Hood

The compiler reads source code and converts it into an intermediate form, then into assembly language. The assembler turns assembly into machine code stored in object files. The linker combines these object files, resolving symbol references and creating an executable with a proper format understood by the OS. When executed, the OS loads the program into memory, sets up the stack and heap, and starts running instructions from the entry point.

Why designed this way?

This multi-step design separates concerns: the compiler focuses on code translation, the assembler on machine code generation, and the linker on combining code pieces. This modularity allows reuse of libraries, incremental builds, and easier debugging. Early computers had limited resources, so this design evolved to optimize memory and processing.

┌───────────────┐     ┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│ Source Code   │────▶│ Compiler      │────▶│ Object Files  │────▶│ Linker        │
└───────────────┘     └───────────────┘     └───────────────┘     └───────────────┘
                                                                      │
                                                                      ▼
                                                             ┌─────────────────┐
                                                             │ Executable File │
                                                             └─────────────────┘
                                                                      │
                                                                      ▼
                                                             ┌─────────────────┐
                                                             │ Operating System│
                                                             └─────────────────┘
                                                                      │
                                                                      ▼
                                                             ┌─────────────────┐
                                                             │ Running Program │
                                                             └─────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does the compiler run your program? Commit to yes or no.

Common Belief: The compiler runs the program after compiling it.

Reality: The compiler only translates code; the operating system runs the program.

Why it matters: Confusing these roles can lead to misunderstanding where errors occur and how to debug them.

Quick: Is linking always done before running the program? Commit to yes or no.

Common Belief: Linking always happens before execution, so the executable contains all code.

Reality: Dynamic linking happens at runtime, loading some code only when needed.

Why it matters: Ignoring dynamic linking can cause missing library errors or confusion about program dependencies.

Quick: Does compiler optimization change what your program does? Commit to yes or no.

Common Belief: Optimizations can change the program’s output to make it faster.

Reality: Optimizations must preserve the program’s behavior, only improving performance or size.

Why it matters: Misunderstanding this can cause mistrust in compiler optimizations or incorrect debugging assumptions.

Quick: Does the linker pick the first function it finds when multiple exist? Commit to yes or no.

Common Belief: The linker always picks the first function definition it encounters.

Reality: The linker follows complex rules for symbol resolution, which can lead to unexpected choices or errors.

Why it matters: Not knowing this can cause subtle bugs or build failures in large projects.

Expert Zone

1

Linkers can perform dead code elimination by removing unused functions, reducing executable size.

2

Compiler optimizations can reorder instructions, affecting debugging and timing-sensitive code.

3

Symbol visibility controls (like static or extern) affect linking and can prevent symbol conflicts.

When NOT to use

Static linking is not ideal for programs that need frequent updates or share common libraries; dynamic linking or containerization might be better. Also, for interpreted languages, this process differs significantly.

Production Patterns

Large projects use build systems to manage compilation and linking efficiently, with incremental builds and dependency tracking. Continuous integration pipelines automate these steps to catch errors early.

Connections

Operating System Process Management

Builds-on

Understanding how the OS loads and runs executables deepens knowledge of program execution beyond compilation.

Software Version Control

Related workflow

Version control manages source code changes that feed into the compilation process, linking development and build stages.

Translation and Interpretation in Linguistics

Analogous process

Both involve converting information from one form to another to enable understanding and action, highlighting universal patterns in communication.

Common Pitfalls

#1 Trying to run source code directly without compiling.

Wrong approach:

g++ program.cpp
./program.cpp

Correct approach:

g++ program.cpp -o program
./program

Root cause:

Misunderstanding that source code must be compiled into an executable before running.

#2 Forgetting to link all object files, causing undefined references.

Wrong approach:

g++ main.o
// missing other.o causing linker errors

Correct approach:

g++ main.o other.o -o program

Root cause:

Not knowing that all compiled parts must be linked together to form a complete program.

#3 Using incompatible library versions causing runtime errors.

Wrong approach:

Running executable without matching dynamic libraries installed.

Correct approach:

Ensuring correct library versions are installed or statically linking needed libraries.

Root cause:

Ignoring dynamic linking dependencies and version compatibility.

Key Takeaways

Compilation transforms human-readable C++ code into machine code through multiple stages.

The linker combines compiled pieces into a single executable that the operating system can run.

Execution involves the OS loading the program and managing resources during runtime.

Understanding static and dynamic linking explains program dependencies and update strategies.

Compiler optimizations improve performance but require careful understanding to avoid subtle bugs.