C++
Fichiers d'en-tête

Remarques

Exemple de base

L'exemple suivant contiendra un bloc de code à scinder en plusieurs fichiers sources, comme indiqué par // filename comment.

Fichiers source

// my_function.h

/* Note how this header contains only a declaration of a function.
 * Header functions usually do not define implementations for declarations
 * unless code must be further processed at compile time, as in templates.
 */

/* Also, usually header files include preprocessor guards so that every header
 * is never included twice.
 *
 * The guard is implemented by checking if a header-file unique preprocessor
 * token is defined, and only including the header if it hasn't been included
 * once before.
 */
#ifndef MY_FUNCTION_H
#define MY_FUNCTION_H

// global_value and my_function() will be
// recognized as the same constructs if this header is included by different files.
const int global_value = 42;
int my_function();

#endif // MY_FUNCTION_H

// my_function.cpp

/* Note how the corresponding source file for the header includes the interface  
 * defined in the header so that the compiler is aware of what the source file is 
 * implementing.
 *
 * In this case, the source file requires knowledge of the global constant
 * global_value only defined in my_function.h. Without inclusion of the header
 * file, this source file would not compile.
 */
#include "my_function.h" // or #include "my_function.hpp"
int my_function() {
  return global_value; // return 42;
}

Les fichiers d'en-tête sont ensuite inclus par d'autres fichiers sources qui souhaitent utiliser la fonctionnalité définie par l'interface d'en-tête, mais ne nécessitent pas de connaissances sur son implémentation (réduisant ainsi le couplage de code). Le programme suivant utilise l'en-tête my_function.h tel que défini ci-dessus:

// main.cpp

#include <iostream>       // A C++ Standard Library header.
#include "my_function.h"  // A personal header

int main(int argc, char** argv) {
  std::cout << my_function() << std::endl;
  return 0;
}

Le processus de compilation

Les fichiers d'en-tête faisant souvent partie d'un workflow de processus de compilation, un processus de compilation classique utilisant la convention d'en-tête / fichier source effectue généralement les opérations suivantes.

En supposant que le fichier d'en-tête et le fichier de code source se trouvent déjà dans le même répertoire, un programmeur exécutera les commandes suivantes:

g++ -c my_function.cpp       # Compiles the source file my_function.cpp
                             # --> object file my_function.o

g++ main.cpp my_function.o   # Links the object file containing the 
                             # implementation of int my_function()
                             # to the compiled, object version of main.cpp
                             # and then produces the final executable a.out

Sinon, si vous souhaitez compiler d'abord main.cpp dans un fichier objet, puis ne lier que les fichiers objets comme étape finale:

g++ -c my_function.cpp
g++ -c main.cpp

g++ main.o my_function.o

Modèles dans les fichiers d'en-tête

Les modèles requièrent la génération de code à la compilation: une fonction basée sur un modèle, par exemple, sera effectivement transformée en plusieurs fonctions distinctes une fois qu'une fonction basée sur un modèle est paramétrée par utilisation dans le code source.

Cela signifie que la fonction de modèle, la fonction membre et les définitions de classe ne peuvent pas être déléguées à un fichier de code source distinct, car tout code qui utilisera une construction basée sur un modèle nécessite la connaissance de sa définition pour générer un code dérivé.

Ainsi, le code modélisé, s'il est placé en en-tête, doit également contenir sa définition. Un exemple de ceci est ci-dessous:

// templated_function.h

template <typename T>
T* null_T_pointer() {
  T* type_point = NULL; // or, alternatively, nullptr instead of NULL
                        // for C++11 or later
  return type_point;
}