top of page

Your Ultimate Guide to Compilation in C

Introduction to Compilation in C

C, a powerful and efficient programming language, has been a staple in software development for decades. One of the essential aspects of working with C is understanding how the source code is transformed into an executable program. This transformation is known as compilation, which involves several critical phases. This guide will take you through each step of the compilation process in C, providing detailed insights into how your code becomes an executable file.

The Compilation Process in C

Compilation in C involves converting the high-level source code into machine code that the computer can execute. This process can be divided into four main phases: pre-processing, compilation, assembly, and linking. Each phase plays a crucial role in ensuring that the final executable runs correctly and efficiently.

C compilation

Step-by-Step Guide to Compiling a C Program

Before diving into the phases, let’s look at how to compile and run a C program using the GCC compiler on an Ubuntu machine.

Step 1: Creating a C Source File

First, create a C source file using a text editor and save it with a .c extension. For example, create a file named hello.c:


$ vi hello.c

Write a simple C program and save it:


#include <stdio.h>

int main() {

    print("Hello, World!\n");

    return 0;


Step 2: Compiling the Source File

Use the GCC compiler to compile the source file:


$ gcc hello.c -o hello

  • The -o option specifies the output file name. Without it, the default output file name is a.out.

Step 3: Running the Executable

Run the generated executable:


$ ./hello

You should see the output:


Hello, World!

Phases of the Compilation Process

The compilation process can be broken down into four distinct phases: pre-processing, compiling, assembling, and linking. Each phase generates intermediate files that help in transforming the source code into machine code.

1. Pre-Processing

The pre-processing phase involves preparing the source code for compilation by handling directives like #include, #define, and removing comments. The pre-processor generates an intermediate file with the .i extension.

Tasks Performed During Pre-Processing:
  • Removal of Comments: All comments are stripped from the source code.

  • Expansion of Macros: Macro definitions are replaced with their respective values.

  • File Inclusion: All included header files are expanded and merged into the source code.

  • Conditional Compilation: Conditional directives (#if, #ifdef, #endif) are evaluated.

To view the pre-processed output:


$ gcc -E hello.c -o hello.i

$ vi hello.i

2. Compilation

During the compilation phase, the pre-processed source code is converted into assembly code. The compiler generates an intermediate file with the .s extension.

Viewing the Assembly Code:


$ gcc -S hello.i -o hello.s

$ vi hello.s

3. Assembling

The assembly phase involves converting the assembly code into machine code, producing an object file with the .o extension. This file contains binary code but lacks information about external functions and variables.

Generating the Object File:


$ gcc -c hello.s -o hello.o

$ vi hello.o

4. Linking

The linking phase resolves references to external symbols and combines all object files into a single executable. The linker also adds any necessary runtime libraries.

Creating the Executable:


$ gcc hello.o -o hello

Intermediate Files in the Compilation Process

By using the -save-temps option with GCC, you can save all intermediate files generated during the compilation process:


$ gcc -Wall -save-temps hello.c -o hello

This command will produce files hello.i, hello.s, hello.o, and hello (the executable).

Best Practices for Compilation in C

Use Compiler Warnings

Enable all compiler warnings to catch potential issues early:


$ gcc -Wall hello.c -o hello

Optimize Code

Use optimization flags to improve performance:


$ gcc -O2 hello.c -o hello

Debugging Information

Include debugging information to facilitate debugging:


$ gcc -g hello.c -o hello

Static vs. Dynamic Linking

Understand the difference between static and dynamic linking to choose the right approach for your application.

Common Pitfalls and Troubleshooting Tips

Missing Header Files

Ensure all necessary header files are included and correctly referenced.

Undefined References

Resolve undefined references by linking the appropriate libraries.

Compiler Errors and Warnings

Pay attention to compiler errors and warnings and address them promptly.


Understanding the compilation process in C is fundamental for any programmer working with the language. By mastering the steps involved—from pre-processing to linking—you can write more efficient, maintainable, and bug-free code. Following best practices and being aware of common pitfalls will further enhance your ability to work effectively with C.

Key Takeaways

  • Introduction to Compilation in C:

Compilation in C transforms source code into executable programs, essential for software development in C.

  • Compilation Process Steps:

Involves pre-processing, compiling, assembling, and linking to convert high-level code into machine-executable binaries.

  • Step-by-Step Guide:

Create a .c file, compile using GCC, and execute the generated binary to run C programs effectively.

  • Phases of Compilation:

Pre-processing handles directives and macros, compiling converts code to assembly, assembling produces object files, and linking combines them into executables.

  • Best Practices:

Use compiler warnings, optimize code with flags like -O2, include debugging info with -g, and understand static vs. dynamic linking for efficient program development.

  • Common Pitfalls and Tips:

Address issues like missing headers, unresolved references, and compiler errors promptly to ensure successful compilation.

  • Conclusion:

Understanding the compilation process in C is crucial for writing robust, efficient code and debugging effectively.


What is the purpose of pre-processing in C?

Pre-processing prepares the source code for compilation by handling directives, expanding macros, and removing comments.

How can I view the intermediate files generated during compilation?

Use the -save-temps option with GCC to save all intermediate files, such as .i, .s, and .o.

What are the benefits of enabling compiler warnings?

Compiler warnings help catch potential issues early, improving code quality and reducing bugs.

What is the difference between static and dynamic linking?

Static linking includes all library code in the executable, while dynamic linking references shared libraries at runtime.

How do I include debugging information in my executable?

Use the -g option with GCC to include debugging information in the executable.

Why is my C program not compiling?

Common reasons include missing header files, syntax errors, and unresolved references. Carefully check compiler messages and address any issues.

Article Sources


bottom of page