Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

Vous n'avez pas encore de compte Developpez.com ? L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Developpez.com

C++

Choisissez la catégorie, puis la rubrique :

logo
Sommaire > Généralités sur le C++ > Organisation du code source
        Quels fichiers d'en-tête dois-je inclure ?
        Où dois-je inclure les fichiers d'en-tête ?
        Dans quel ordre dois-je mettre mes fichiers d'en-tête ?
        Comment faire avec les templates ?
        Comment vérifier que mon fichier d'en-tête peut être inclus indépendamment de tout autre ?
        Et avec les en-têtes précompilés ?



Quels fichiers d'en-tête dois-je inclure ?
Créé le 15/10/2009[haut]
auteur : 3DArchi
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.

lien : faq Où dois-je inclure les fichiers d'en-tête ?
lien : faq Dans quel ordre dois-je mettre mes fichiers d'en-tête ?
lien : faq Comment faire avec les templates ?
lien : faq Comment vérifier que mon fichier d'en-tête peut être inclus indépendamment de tout autre ?
lien : faq Et avec les en-têtes précompilés ?

Où dois-je inclure les fichiers d'en-tête ?
Créé le 15/10/2009[haut]
auteur : 3DArchi
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.
A.h

class A
{
// déclaration de la classe A
};
B.h

class A; // déclaration anticipée
class B
{
// déclaration de la classe B
// ...

   void do_someting_with_a_A(A const &);
};
B.cpp

#include "B.h"
#include "A.h"
// définition de B...
A noter que la déclaration anticipée n'est possible que si le compilateur n'a pas besoin de connaître complètement le type : pointeur, référence. On ne peut l'utiliser pour l'héritage ou la composition.
Pour aller plus loin avec les déclarations anticipées, jusqu'à présent vous avez l'habitude de découper votre code en deux fichiers : un fichier d'en-tête MyClass.h pour la déclaration et un fichier d'implémentation MyClass.cpp pour la définition. Notez qu'on peut associer un troisième fichier MyClassFwd.h pour regrouper les déclarations anticipées liées à CMyClass. Ce fichier contient tout naturellement une déclaration anticipée de la classe :
class CMyClass;
Mais, c'est l'occasion d'y mettre aussi d'autres déclarations associées qui vont systématiquement (ou presque) avec votre classe. Ce peut être des enum, des déclarations de fonctions externes, etc... :
class CMyClass;
enum E_options_my_class
{
  // ...
};
std::ostream& operator << (std::ostream& O, const CMyClass& B); 
Lorsqu'une autre classe nécessite une déclaration anticipée de CMyClass, elle fait alors appel à cet en-tête :
#include "MyClassFwd.h"

Dans quel ordre dois-je mettre mes fichiers d'en-tête ?
Créé le 15/10/2009[haut]
auteurs : Luc Hermitte, 3DArchi
  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.
Cet ordre est une proposition parmi d'autres qui ont aussi leur légitimité. Vous pouvez suivre un autre ordre d'inclusion si vous en sentez le besoin compte tenu de vos pratiques habituelles ou du contexte de votre application. En fait, l'idée maîtresse est de maintenir une cohérence sur l'ensemble du projet. Quelle que soit la politique que vous choisissez de mettre en œuvre, utilisez la même systématiquement dans tous vos fichiers.


Comment faire avec les templates ?
Créé le 15/10/2009[haut]
auteur : 3DArchi
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 :
MyTemplateClass.h
template<class T>
class TMyTemplateClass
{
public: 
   void do_something();
};
#include "MyTemplateClass.tpp"
MyTemplateClass.tpp
// en-tête si besoin

// définition
template<class T>
void TMyTemplateClass<T>::do_something()
{
}

Comment vérifier que mon fichier d'en-tête peut être inclus indépendamment de tout autre ?
Créé le 15/10/2009[haut]
auteurs : JolyLoic, 3DArchi
Inclure le fichier en tout premier dans un fichier .cpp. Ce dernier doit compiler sans erreur.


Et avec les en-têtes précompilés ?
Créé le 15/10/2009[haut]
auteur : 3DArchi
Les en-têtes précompilés n'offrent malheureusement pas de standard dans leur mise en œuvre. 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.

lien : en  The Care and Feeding of Pre-Compiled Headers


Consultez les autres F.A.Q.


Valid XHTML 1.0 TransitionalValid CSS!

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2008 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Contacter le responsable de la rubrique C++

Partenaire : Hébergement Web