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.