Header and .cpp Files in C++

One of the peculiar things and hardest to understand when working with C++ is that code files are divided into two types of files.

This can be shocking (besides being a hassle), since most modern languages combine declarations and definitions in a single file.

However, when computers were much less powerful, this division helped to reduce compilation times ⌛, especially in large projects (nowadays it doesn’t make much sense anymore).

Although they are not always strictly necessary, .h and .cpp files are still a daily occurrence in any C++ project (let’s face it, you will have to deal with them one way or another).

Introduction to .h and .cpp Files

As mentioned, generally in a C++ project we will have .h and .cpp files.

The .h is like the contract or promise: “I tell you what is available to use.” The .cpp is the implementation: “I tell you how it works.”

Let’s take a closer look at them 👇

Typical Project Structure

In a traditional C++ project, a convention is followed to separate declarations and definitions into different files.

Logically, everyone organizes their project as they wish (especially the large ones). But, in a simple example, typically a project would look like this.

/project
    |-- src/
        |-- main.cpp
        |-- my_class.cpp
    |-- include/
        |-- my_class.h

That is, we would have the different elements separated into folders.

• src/: We would put the implementation files (.cpp).
• include/: We would have the header files (.h).

File Inclusion

The #include directive is used to include the content of one file in another file.

#include "my_class.h"

In the .cpp files, we will include the necessary header files to access the class and function declarations.

Code Example

Let’s see everything together in an example. Suppose we have a class called MyClass.

#ifndef MY_CLASS_H
#define MY_CLASS_H

class MyClass {
public:
    MyClass();                    // Constructor
    void myMethod();              // Public method
private:
    int myVariable;               // Private variable
};

#endif // MY_CLASS_H

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

MyClass::MyClass() : myVariable(0) {
    // Constructor: Initializes myVariable to 0
}

void MyClass::myMethod() {
    std::cout << "My variable is: " << myVariable << std::endl;
}

#include "my_class.h"

int main() {
    MyClass object;
    object.myMethod();
    return 0;
}

Safeguards in C++

A safeguard is a mechanism used to ensure that a header file is not included more than once in a project.

Basically, they are #ifndef, #define, #endif directives that are inserted in the .h header files, which make the compiler include the code only once. Thus,

#ifndef MY_CLASS_H
#define MY_CLASS_H

// Header file content

#endif // MY_CLASS_H

Here,

• #ifndef: Checks if the macro is not defined.
• #define: Defines the macro if it is not already defined.
• #endif: Ends the inclusion guard.

Pragma Once Directive

Instead of using traditional inclusion guards, a more modern way is to use a directive #pragma once.

This directive is more concise and easier to read, and also ensures that a file is included only once during compilation (but without the need to manually define macros).

#pragma once

class MyClass {
public:
    void myMethod();
};

As we can see, #pragma once is much more convenient, as there is no need to wrap all our code in safeguard directives. We simply put a single line at the beginning of the file.