Inclusion des fichiers d'en-tête / Déclaration d'aval

Il y a plusieurs problèmes à l'avant de la déclaration:

• C'est comme le stockage de votre nom de classe dans plusieurs endroits, si vous la changez en un seul endroit, vous avez maintenant de le changer partout ailleurs. Refactoring devient un défi, étant donné que le code compile bien avec le changement de nom de la classe, mais la liaison échoue, car la déclaration référer à un indéfini de la classe. Si vous incluez le fichier d'en-tête et de ne pas utiliser de déclaration, vous pourrez attraper ces problèmes lors de la compilation.

• En avant les déclarations sont difficile pour les autres de maintenir. Par exemple, si un fichier d'en-tête contient:

  include "MyProject/MyWidgets/MyFooWidgets/FooUtil/Foo.h"

  plutôt que l'avant de la déclaration de

   class Foo ;  

  il est facile pour les autres de trouver l'emplacement de la classe Foo est déclarée. Avec l'avant de la déclaration, il n'est pas que
  évident; certains Ide comme Eclipse peut ouvrir la déclaration anticipée lorsque l'utilisateur essaie d'ouvrir
  la déclaration d'une variable.

• Liaison peut échouer avec undefined symbol des erreurs lorsque vous incluez un fichier d'en-tête dans votre code qui contient une déclaration anticipée, mais la réelle définition de code se trouve dans une autre bibliothèque que vous n'avez pas de lien avec. C'est plus pratique pour prendre ce problème au moment de la compilation avec des erreurs comme "Could not find file MyProject/MyWidgets/MyFooWidgets/FooUtil/Foo.h" depuis, alors vous savez où chercher pour le correspondant Foo.cpp et d'identifier la bibliothèque qui le contient.

Si vous pensez que votre version est trop long, puis essayer de faire une compile seulement avec pas de lien. Si votre code ne prend que 10 secondes à compiler et à 10 minutes de lien, le problème n'a rien à voir avec un peu plus de comprend. De même, si votre fichier d'en-tête contient tellement de choses qu'il est en fait à l'origine d'un problème de performances, alors il est probablement temps pour vous de revoir le contenu de ce fichier en plusieurs petits fichiers d'en-tête.

Alors, quand est-il OK pour déclarer avant? Si vous le faites dans le même fichier d'en-tête comme le véritable déclaration.

Exemple:

class Foo ;

typedef Foo* FooPtr ;
typedef Foo& FooRef ;

class Foo
{
   public:
      Foo( ) ;
      ~Foo( ) ;
}

OU

class TreeNode ;

class Tree
{
private:
   TreeNode m_root ;
}

class TreeNode
{
   void* m_data ;
} ;

Comme un débutant, vous devez toujours #inclure les fichiers d'en-tête lorsque vous avez besoin d'utiliser les types ou les fonctions qu'ils contiennent, ne pas essayer de "optimiser" votre construction par l'avant de déclarer des choses - ce n'est presque jamais nécessaire, même sur de grands projets, à condition que le projet est bien conçu.

Le seul moment où vous en avez absolument besoin d'une déclaration anticipée est dans ce genre de situations:

struct A {
   void f( B b );
};

struct B {
   void f( A a );
};

où chaque structure (ou de classe) désigne le type de l'autre. Dans ce cas, vous avez besoin d'une déclaration anticipée de B pour résoudre le problème:

struct B;   //forward declaration

struct A {
   void f( B b );
};

struct B {
   void f( A a );
};