What are .hpp headers in C++ and what are they for?

So what are .hpp headers in C++ and what are they for?

C language headers have an extension .h(header). Since C++ is another language, it was decided to use a different extension, which would be .hpp(header plus plus).

But it's an arbitrary choice, you can use whatever extension you like for headers; As long as the compiler is able to read and interpret the content of a file, the header will be irrelevant:

#include <iostream>
#include <stdio.h>

#include "Ejercicio1.txt"
#include "Patatas.fritas"
#include "no_tengo_extension"

int main() { return 0; }

I can assure you that if the Ejercicio1.txt, Patatas.fritasy files no_tengo_extensionexist, any C++ compiler will accept them.

When structuring a code in C++ you can choose to put all the code in a single file:

file1

#include <iostream>

void func(int var)
{
  std::cout << var*2;
}

main.cpp

#include "fichero1"

int main()
{
  func(3);
}

This solution poses several problems that become apparent when the project starts to grow in size:

• Each modification of the file entails a recompilation of all the files that include it, which can delay the compilation process for several minutes or even hours.
• Resolving mutual dependencies becomes complicated. The following code, for example, will not compile:

fileA

#pragma once
#include "ficheroB"

struct A
{
  void func(B* b)
  { b->func1(); }

  void func1()
  { std::cout << "A\n"; }
};

fileB

#pragma once
#include "ficheroA"

struct B
{
  void func(A* a)
  { a->func1(); }

  void func1()
  { std::cout << "B\n"; }
};

main.cpp

#include "ficheroA"
#include "ficheroB"

int main()
{
  A a;
  B b;

  a->func(b);
  b->func(a);
}

Note: I have chosen to use #pragma onceeven if it is not standard to put the least amount of decoration into the code.

To solve these two problems we can choose to divide the functions and classes into two (definition and implementation):

• definition: It is the public part or header and indicates the interface of the function or class.
• implementation: It is the private part. Here is the source code.

The above example duly adapted:

fileA

#pragma once

class B;

struct A
{
  void func(B* b);

  void func1();
};

fileA.cpp

#include "ficheroA"
#include "ficheroB"

void A::func(B* b)
{ b->func1(); }

void A::func1()
{ std::cout << "A\n"; }

fileB

#pragma once

class A;

struct B
{
  void func(A* a);

  void func1();
};

fileB.cpp

#include "ficheroA"
#include "ficheroB"

void B::func(A* a)
{ a->func1(); }

void B::func1()
{ std::cout << "B\n"; }

By separating the declaration from the implementation, the interdependency has been resolved (the dependency has been moved to the implementation file, on which no other file depends) and the code can now be compiled.

Thus, the headers will be used to indicate the interface of the classes and functions, leaving the source code relegated to the implementation files.

Note: The inline, constexprand functions templatemust host the implementation in the header as current limitations prevent the compiler from locating their implementation in a source code file.