Ficheros .h y .cpp en C++

Una de las cosas peculiares y que más cuesta de entender al trabajar con C++ es que los ficheros de código se dividen en dos tipos de ficheros.

Esto es puede resultar chocante (además de un engorro), ya que la mayoría de lenguajes modernos declaraciones y definiciones en un solo archivo.

Sin embargo, cuando los ordenadores eran mucho menos potentes esta división ayudaba a reducir los tiempos de compilacion ⌛, sobre todo en proyectos grandes (en la actualidad ya no tienen mucho sentido).

Aunque no siempre son estrictamente necesarios, los ficheros .h y .cpp siguen siendo el día a día en cualquier proyecto de C++ (vamos, que vais a tener que lidiar con ellos sí o sí)

Introducción a los Ficheros .h y .cpp

Como decía, generalmente en un proyecto de C++ tendremos ficheros .h y .cpp.

El .h es como el contrato o la promesa: “Te digo qué hay disponible para usar.” El .cpp es la implementación: “Te digó cómo funciona.”

Vamos a verlos un poco más en detalle 👇

Estructura típica de un proyecto

En un proyecto C++ tradicional, se sigue una convención de separar las declaraciones y las definiciones en diferentes archivos.

Lógicamente, cada uno organiza su proyecto como quiere (sobre todo los grandes). Pero, en un ejemplo sencillo, típicamente un proyecto tendría esta pinta.

/proyecto
    |-- src/
        |-- main.cpp
        |-- mi_clase.cpp
    |-- include/
        |-- mi_clase.h

Es decir, tendríamos separados en carpetas los distintos elementos.

• src/: Meteríamos los archivos de implementación (.cpp).
• include/: Tendríamos los archivos de encabezado (.h).

Inclusión de archivos

La directiva #include se utiliza para incluir el contenido de un archivo en otro archivo.

#include "mi_clase.h"

En los archivos .cpp, incluiremos los archivos de encabezado necesarios para acceder a las declaraciones de clases y funciones.

Ejemplo de código

Vamos a verlo mejor todo junto en un ejemplo. Supongamos que tenemos una clase llamada MiClase.

#ifndef MI_CLASE_H
#define MI_CLASE_H

class MiClase {
public:
    MiClase();                    // Constructor
    void miMetodo();              // Método público
private:
    int miVariable;               // Variable privada
};

#endif // MI_CLASE_H

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

MiClase::MiClase() : miVariable(0) {
    // Constructor: Inicializa miVariable a 0
}

void MiClase::miMetodo() {
    std::cout << "Mi variable es: " << miVariable << std::endl;
}

#include "mi_clase.h"

int main() {
    MiClase objeto;
    objeto.miMetodo();
    return 0;
}

Salvaguarda en C++

Una salvaguarda es un mecanismo que se utiliza para que un archivo de encabezado no se incluya más de una vez en un proyecto.

Básicamente son directivas #ifndef, #define, #endif que se insertan en los archivos de cabecera .h, que hacen que el compilador incluya el código una única vez. Así,

#ifndef MI_CLASE_H
#define MI_CLASE_H

// Contenido del archivo de encabezado

#endif // MI_CLASE_H

Aquí,

• #ifndef: Verifica si la macro no está definida.
• #define: Define la macro si no está ya definida.
• #endif: Finaliza la guarda de inclusión

Directiva pragma once

En lugar de usar las tradicionales guardas de inclusión , una forma más moderna es usar una directiva #pragma once.

Esta directiva es más concisa y fácil de leer, e igualmente asegura que un archivo se incluya solo una vez durante la compilación (pero sin necesidad de definir macros manualmente).

#pragma once

class MiClase {
public:
    void miMetodo();
};

Como vemos, #pragma once es mucho más cómoda, ya que no hace falta envolver todo nuestro código en directivas de salvaguarda. Simplemente ponemos una única línea al principio del fichero.