Header-Dateien in

Über Header-Dateien

In C++ werden Deklarationen oft von Definitionen getrennt. Deklarationen werden in sogenannten Header-Dateien gruppiert, während die jeweiligen Implementierungen in Quelldateien liegen. Du kannst dir die Header-Dateien wie eine API vorstellen. Die Header-Datei sagt dir, was eine Codebasis zu bieten hat, ohne auf die Details des Wie einzugehen.

Header und Quelldatei

Die gebräuchlichste Dateiendung für Header-Dateien ist .h. Manche Projekte verwenden .hpp oder lassen die Endung ganz weg.

Die Definitionen stehen in einer separaten .cpp-Datei. Um die Teile wieder zusammenzuführen, beginnt die Quelldatei damit, die jeweilige Header-Datei einzubinden.

Wenn du eine Bibliothek namens „quick_math" schreiben willst, die eine Funktion „super_root" anbietet, die du oft verwenden möchtest, sehen die Dateien so aus:

// A file named quick_math.h
#pragma once

namespace quick_math {

double super_root(double x, int n);

}

// A file named quick_math.cpp
#include <cmath>

#include "quick_math.h"

double quick_math::super_root(double x, int n) {
    while (n) {
        x = std::sqrt(x), --n;
    }
    return x;
}

Wenn du einen Header einbinden musst, der nur für die Implementierung nötig ist, wird die entsprechende #include-Zeile nur in der Quelldatei gebraucht. Alles, was im Header eingebunden ist, steht auch in der .cpp-Datei zur Verfügung, wie die string-Bibliothek im folgenden Beispiel. Achtung: Das ; wird nach der Deklaration in der Header-Datei gebraucht, aber nicht nach der Definition in der Quelldatei.

Klassen und Header

Klassen können sehr komplex werden, und ihr Verhältnis zur Aufteilung in Header und Quelldatei ist vielleicht verwirrend. Eine mögliche Aufteilung ist, alle Implementierungsdetails in der Quelldatei zu lassen und alle Deklarationen und Membervariablen in den Header zu schreiben:

// A file named robot_flower.h
#if !defined(ROBOT_FLOWER_H)
#define ROBOT_FLOWER_H

#include <string>

namespace robots {

class Flower {
   private:
    bool needs_water{};
    int size{};
    std::string name{};

   public:
    Flower(std::string name, int size = 0);
    void give_water();
    std::string get_name();
    int get_size();
    void start_next_day();
};
}  // namespace robots
#endif

// A file named robot_flower.cpp
#include "robot_flower.h"

robots::Flower::Flower(std::string name, int size) {
    this->name = "Robotica " + name;
    this->size = size;
}

void robots::Flower::start_next_day() {
    if (!needs_water) ++size;
    needs_water = true;
}

std::string robots::Flower::get_name() { return name; }

int robots::Flower::get_size() { return size; }

Wenn der Header als API-Übersicht dient, schaut man genau dort nach Informationen wie Standardwerten. Der Standardwert des size-Parameters des Konstruktors wird deshalb im Header festgelegt und nicht in der Implementierung. Den Definitionen in der Quelldatei werden der Namensraum robots und der Klassentyp Flower vorangestellt.

Eine weitere Aufteilungsmöglichkeit ist eine Header-only-Bibliothek, die überhaupt keine .cpp-Datei hat:

// A file named robot_flower.h
#pragma once

#include <string>

namespace robots {

class Flower {
   private:
    bool needs_water{};
    int size{};
    std::string name{};

   public:
    Flower(std::string name, int size = 0) {
        this->name = "Robotica " + name;
        this->size = size;
    }
    void give_water() { needs_water = false; }
    std::string get_name() { return name; }
    int get_size() { return size; }
    void start_next_day() {
        if (!needs_water) ++size;
        needs_water = true;
    }
};
}  // namespace robots

Projekte verwenden vielleicht Kombinationen dieser Aufteilungen, und es wird viel darüber diskutiert, was für den jeweiligen Anwendungsfall am besten passt.

Include Guards

Vielleicht ist dir die Zeile #pragma once in der obigen Beispiel-Header-Datei aufgefallen. Das nennt man einen Include-Guard. Er sorgt dafür, dass der Inhalt der Datei während der Kompilierung nur einmal eingebunden wird, um Fehler zu vermeiden. Es gibt noch eine andere, komplexere Variante eines Include-Guards, die mit #ifndef beginnt und mit #endif endet und weiter unten beschrieben wird.

int myFunction(int n) {
    if (n < 10) {
        return n;
    } else {
        return myOtherFunction(n / 10);
    }
}

int myOtherFunction(int m) { return myFunction(m / 2); }

int myFunction(int n);       // Forward declaration of myFunction
int myOtherFunction(int m);  // Forward declaration of myOtherFunction

// Definition of myFunction
int myFunction(int n) {
    if (n < 0) {
        return 0;
    } else {
        return myOtherFunction(n - 2);
    }
}

// Definition of myOtherFunction
int myOtherFunction(int m) { return myFunction(m / 2); }

#ifndef MY_HEADER_FILE_H /* any name uniquely mapped to file name */
#define MY_HEADER_FILE_H

// file content

#endif