CPP Tutorial

Understanding Header Files and Source Files in C++

Youwei Chen's photo
Youwei Chen
·

3 min read

Table of contents

Header Files (.h)

Header files are used to declare the interface of our code.

Source Files (.cpp):

In C++, a source file contain implementations of functions/classes.

Purpose of Header Files:

  • Declare, not define: Header files declare what functions, classes, and variables exist, but they usually do not contain the actual implementation.

  • Reusability: Header files allow us to share declarations across multiple source files (.cpp files).

  • Modularity: Header files help organize code into logical units.

Step 1: Create a Header File (math_utils.h)

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

// Function declarations
int add(int a, int b);
int multiply(int a, int b);

#endif // MATH_UTILS_H

Step 2: Implement Functions in a Source File (math_utils.cpp)

#include "math_utils.h"

// Function implementations
int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

Why separate implementation from declaration?

  • Encapsulation - Keeps implementation details hidden.

  • Reusability - Multiple .cpp files can use math_utils.h without duplicating function code.

Step 3: Use the Functions in main.cpp

#include <iostream>
#include "math_utils.h"

int main() {
    int x = 5, y = 10;
    std::cout << "Sum: " << add(x, y) << std::endl;
    std::cout << "Product: " << multiply(x, y) << std::endl;
    return 0;
}

Why include math_utils.h?

  • math_utils.h provides function declarations, ensuring main.cpp knows about add() and multiply()

Include Guards:

Include guards are a technique used in C and C++ to prevent a header file from being included more than once in the same translation unit (i.e., the same .cpp file)

Why Are Include Guards Needed?

When we include a header file in multiple places, the compiler processes the contents of that header file each time it is included. If the header file contains class definitions, function declarations, or constants, the compiler will see these definitions multiple times, which violates the One Definition Rule(ODR) in C++. This will result in compilation errors like:

error: redefinition of 'class MyClass'
error: 'int myFunction()' previously declared here

Include guards prevent this by ensuring that the contents of the header file are only included once, even if the file is referenced multiple times.

How Do Include Guards Work?

Include Guards use preprocessor directive (#ifndef, #define, #endif) to conditionally include the contents of a header file. Here’s how they work:

  1. #ifndef: Stands for “if not defined“. It checks whether a specific macro has been defined.

  2. #define: Defines a macro if it hasn’t been defined yet.

  3. #endif: Marks the end of the conditional block.

When the header file is included for the first time, the macro is not defined, so the compiler processes the contents of the file. On subsequent inclusions, the macro is already defined, so the compiler skips the contents of the file.

Syntax of Include Guards

Here’s the standard structure of include guards:

#ifndef UNIQUE_MACRO_NAME
#define UNIQUE_MACRO_NAME

// Header file content (e.g., function declarations, class definitions, etc.)

#endif // UNIQUE_MACRO_NAME
  • UNIQUE_MACRO_NAME: This should be a unique macro name for the header file, typically based on the file name. (e.g., MY_HEADER_H for my_header.h)

Preprocessor Directive

Preprocessor directives in C++ are instructions that execute before compilation. They are handled by the C++ preprocessor and typically starts with a # symbol.

Types of Preprocessor Directives:

  1. Macro Definition(#define)

    Used to define constants or inline functions.

     #define PI 3.14159
 #define SQUARE(x) ((x) * (x))

 #include <iostream>
 int main() {
     std::cout << "PI: " << PI << std::endl;
     std::cout << "Square of 4: " << SQUARE(4) << std::endl;
     return 0;
 }

  2. File Inclusion (#include)

    Used to include header files

     #include <iostream>  // Standard library
 #include "myheader.h" // User-defined header

  3. Conditional Compilation (#ifdef, #ifndef, #endif)

    Used to enable or disable sections of code based on macro definitions.

C++