Header and .cpp Files in C++

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

This can be surprising (and also a hassle), since most modern languages have declarations and definitions in a single file.

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

Although not always strictly necessary, .h and .cpp files are still part of the daily routine in any C++ project (so you’ll have to deal with them one way or another).

Introduction to .h and .cpp Files

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

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

Let’s look at them in a bit more detail 👇

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 want (especially large ones). But, in a simple example, a project would typically look like this.

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 into another file.

#include "my_class.h"

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

Code Example

Let’s see it all together better 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;
}

Include Guards in C++

An include guard is a mechanism used to ensure a header file is not included more than once in a project.

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

#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’s not already defined.
• #endif: Ends the include guard.

The pragma once Directive

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

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

#pragma once

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

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