FAQ C++Consultez toutes les FAQ

Le strict minimum : c'est-à-dire les seuls fichiers d'en-tête contenant les déclarations ou définitions de ce qui va être utilisé et permettant ainsi à la compilation de réussir.

Il est préférable d'avoir des déclarations anticipées (forward declaration) dans les fichiers d'en-tête et d'inclure l'en-tête de déclaration dans le fichier source. L'objectif à atteindre est que tout fichier d'en-tête doit pouvoir être inclus indépendamment des autres et compiler. Ce qui veut dire qu'un fichier d'en-tête doit contenir le moins de choses possibles.

1
2
3
4
class A 
{ 
    // déclaration de la classe A 
};

1
2
3
4
5
6
7
8
class A; // déclaration anticipée 
class B 
{ 
    // déclaration de la classe B 
    // … 
  
   void do_someting_with_a_A(A const &); 
};

1
2
3
#include "B.h" 
#include "A.h" 
// définition de B…

class CMyClass;

1
2
3
4
5
6
class CMyClass; 
enum E_options_my_class 
{ 
   // … 
}; 
std::ostream& operator << (std::ostream& O, const CMyClass& B);

#include "MyClassFwd.h"

1. Le fichier d'en-tête de la déclaration de la classe ;
2. les fichiers standards (STL) ;
3. les fichiers d'en-tête de l'O.S. ;
4. les fichiers d'en-tête des bibliothèques tierces (boost, xml, wxWidget…) ;
5. les fichiers d'en-tête de mes bibliothèques externes ;
6. les fichiers d'en-tête de mon projet.
   

Une classe est déclarée dans un fichier header (extension .h, .hpp. ou encore .hxx) dont l'inclusion multiple est protégée grâce à des directives du préprocesseur :

1
2
3
4
5
6
7
8
9
10
#ifndef MACLASSE_H 
#define MACLASSE_H 
  
class MaClasse 
{ 
public: 
    void Fonction(); 
}; 
  
#endif

1
2
3
4
5
6
#include "maclasse.h" 
  
void MaClasse::Fonction() 
{ 
    // implémentation de la fonction 
}

1
2
3
4
5
6
7
8
#include "autreclasse.h" 
#include "maclasse.h" 
  
void AutreClasse::Fonction() 
{ 
    MaClasse M; 
    M.Fonction(); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#ifndef MACLASSE_H 
#define MACLASSE_H 
  
class MaClasse 
{ 
public: 
    void FonctionInline() 
    { 
        // Placée dans la déclaration de la classe 
        // cette fonction est considérée en ligne sans 
        // que le mot clé inline ne figure 
    } 
}; 
  
// Placée en dehors de la déclaration de la classe, le mot clé inline 
// est indispensable pour ne pas provoquer des définitions multiples 
// de la fonction et donc des erreurs à l'édition de liens 
inline void FonctionInline2() 
{ 
} 
#endif

Les templates nécessitent d'avoir toute la définition dans le fichier d'en-tête. Pour maintenir une politique cohérente, on peut séparer la déclaration d'une classe template (.h) et sa définition (.tpp). La définition est incluse à la fin du fichier de déclaration :

1
2
3
4
5
6
7
template<class T> 
class TMyTemplateClass 
{ 
public:  
   void do_something(); 
}; 
#include "MyTemplateClass.tpp"

1
2
3
4
5
6
7
// en-tête si besoin 
  
// définition 
template<class T> 
void TMyTemplateClass<T>::do_something() 
{ 
}

Inclure le fichier en tout premier dans un fichier .cpp. Ce dernier doit compiler sans erreur.

Les en-têtes précompilés n'offrent malheureusement pas de standard dans leur mise en ouvre. Tous les compilateurs ne les supportent pas, et ceux qui savent les gérer ne le font pas tous de la même façon. Est-ce une raison pour les abandonner ? Non. Car ils offrent de vrais avantages en terme de temps de compilation, surtout pour les projets utilisant des bibliothèques volumineuses ou complexes. La question qui se pose alors est de savoir quoi mettre dans les en-têtes précompilés ? Il faut garder à l'esprit l'objectif des en-têtes précompilés : accélérer la compilation. Il faut donc veiller à mettre les fichiers des bibliothèques externes récurrents dans vos sources ainsi que ceux qui sont susceptibles de provoquer des inclusions en cascade (afxXXX.h avec les MFC, wx.h dans wxWidgets). En revanche ne mettez pas des fichiers d'en-têtes du projet en cours car ce sont ceux qui sont le plus susceptibles de varier et dégradent ainsi le temps de compilation en forçant à tout recompiler.
Il faut être vigilant à ne pas transformer le fichier d'en-têtes précompilés en un fourre-tout contenant tous les fichiers de toutes les bibliothèques utilisées dans un projet. Cela rompt le principe qui veut que l'on minimise les dépendances entre les unités de compilation. Identifiez correctement les fichiers clés qui sont significatifs dans le temps de compilation de votre projet.