C++ #include gardes

Le préprocesseur est un programme qui prend votre programme, apporte quelques modifications (par exemple inclure des fichiers (#include), la macro-expansion (#define), et en gros, tout ce qui commence avec #) et donne le "nettoyer" le résultat de la compilation.

Le préprocesseur œuvres de ce genre quand il voit #include:

Lorsque vous écrivez:

#include "some_file"

Le contenu de some_file presque littéralement obtenir une copie collé dans le fichier, y compris elle. Maintenant, si vous avez:

a.h:
class A { int a; };

Et:

b.h:
#include "a.h"
class B { int b; };

Et:

main.cpp:
#include "a.h"
#include "b.h"

Vous bénéficiez de:

main.cpp:
class A { int a; };  //From #include "a.h"
class A { int a; };  //From #include "b.h"
class B { int b; };  //From #include "b.h"

Maintenant, vous pouvez voir comment A est redéfini.

Lorsque vous écrivez des gardes, ils deviennent comme ceci:

a.h:
#ifndef A_H
#define A_H
class A { int a; };
#endif

b.h:
#ifndef B_H
#define B_H
#include "a.h"
class B { int b; };
#endif

Alors maintenant, regardons comment #includes en principal serait élargie (c'est exactement, comme dans le cas précédent: le copier-coller)

main.cpp:
//From #include "a.h"
#ifndef A_H
#define A_H
class A { int a; };
#endif
//From #include "b.h"
#ifndef B_H
#define B_H
#ifndef A_H          //From
#define A_H          //#include "a.h"
class A { int a; };  //inside
#endif               //"b.h"
class B { int b; };
#endif

Maintenant, nous allons suivre le préprocesseur et voir ce que les "vrais" code vient de là. Je vais aller ligne par ligne:

//From #include "a.h"

Commentaire. Ignorez-le! Continuer:

#ifndef A_H

Est A_H défini? Non! Puis continuer:

#define A_H

Ok maintenant A_H est défini. Continuer:

class A { int a; };

Ce n'est pas quelque chose de préprocesseur, il suffit donc de le laisser être. Continuer:

#endif

La précédente if fini ici. Continuer:

//From #include "b.h"

Commentaire. Ignorez-le! Continuer:

#ifndef B_H

Est B_H défini? Non! Puis continuer:

#define B_H

Ok maintenant B_H est défini. Continuer:

#ifndef A_H          //From

Est A_H défini? OUI! Puis de les ignorer jusqu'à ce correspondant #endif:

#define A_H          //#include "a.h"

Ignorer

class A { int a; };  //inside

Ignorer

#endif               //"b.h"

La précédente if fini ici. Continuer:

class B { int b; };

Ce n'est pas quelque chose de préprocesseur, il suffit donc de le laisser être. Continuer:

#endif

La précédente if fini ici.

Qui est, après le préprocesseur est fait avec le fichier, c'est ce que le compilateur voit:

main.cpp
class A { int a; };
class B { int b; };

Donc, comme vous pouvez le voir, tout ce que l'on peut obtenir #included en deux fois le même fichier, que ce soit directement ou indirectement, doit être surveillé. Depuis .h les fichiers sont toujours très susceptibles d'être inclus deux fois, c'est bon si tu gardes TOUS vos .h fichiers.

P. S. Notez que vous avez également la circulaire #includes. Imaginez le préprocesseur copier-coller le code de la Physique.h en GameObject.h, qui voit, il y a un #include "GameObject.h" qui signifie copie GameObject.h en lui-même. Lorsque vous copiez, vous pouvez à nouveau obtenir #include "Pysics.h" et vous êtes coincé dans une boucle pour toujours. Les compilateurs de l'en empêcher, mais cela signifie que votre #includes sont à moitié fait.

Avant de dire comment résoudre ce problème, vous devez savoir une autre chose.

Si vous avez:

#include "b.h"

class A
{
    B b;
};

Ensuite, le compilateur a besoin de tout savoir sur b, plus important encore, quelles variables il a etc de sorte qu'il serait de savoir combien d'octets il devrait mettre en place des b dans A.

Toutefois, si vous avez:

class A
{
    B *b;
};

Puis le compilateur n'a pas vraiment besoin de savoir quelque chose au sujet de B (puisque les pointeurs, quel que soit le type ont la même taille). La seule chose qu'il a besoin de savoir à propos de B est qu'il existe!

Si vous faites quelque chose appelé "déclaration anticipée":

class B;  //This line just says B exists

class A
{
    B *b;
};

C'est très semblable à beaucoup d'autres choses que vous faites dans les fichiers d'en-tête comme:

int function(int x);  //This is forward declaration

class A
{
public:
    void do_something(); //This is forward declaration
}

Le problème est que votre GameObject.h n'a pas de gardes, de sorte que lorsque vous #include "GameObject.h" dans Physics.h il est inclus lorsque GameObject.h comprend Physics.h.

Tout d'abord, vous devez inclure les gardes sur gameobject trop, mais ce n'est pas le vrai problème ici

Si quelque chose d'autre comprend la physique.h tout d'abord, la physique.h comprend gameobject.h, vous obtenez quelque chose comme ceci:

class GameObject {
...
};

#include physics.h

class Physics {
...
};

et le #include physique.h est rejeté en raison de l'inclure des gardes, et vous vous retrouvez avec une déclaration de GameObject avant la déclaration de la Physique.

Mais c'est un problème si vous voulez GameObject à avoir un pointeur vers une Physique, parce que pour htat physique devraient être déclarés en premier.

Pour résoudre le cycle, vous pouvez transmettre la déclaration d'une classe à la place, mais seulement si vous êtes juste de l'utiliser comme un pointeur ou une référence dans la déclaration suivante, à savoir:

#ifndef PHYSICS_H
#define PHYSICS_H

// no need for this now #include "GameObject.h"

#include <list>

class GameObject;

class Physics
{
private:
    list<GameObject*> objects;
    list<GameObject*>::iterator i;
public:
    void ApplyPhysics(GameObject*);
    Vector2X CheckCollisions(Vector2X, GameObject*);
};

#endif //PHYSICS_H

L'objectif d'un en-tête de la garde est à éviter, y compris le même fichier plusieurs fois.
Mais l'en-tête de la garde qui est actuellement utilisé en C ++ peut être amélioré. L'actuel garde:

#ifndef AAA_H
#define AAA_H

class AAA
{ /* ... */ };

#endif

Ma nouvelle garde proposition est:

#ifndef AAA_H
#define AAA_H

class AAA
{ /* ... */ };

#else
class AAA;  //Forward declaration
#endif

Cela résout le problème gênant qui se produit lorsque l'AAA les besoins de la classe la classe BBB déclaration, tandis que la classe BBB besoins de l'AAA de la déclaration de classe, généralement parce qu'il ya traversé les pointeurs d'une classe à l'autre:

//File AAA.h
#ifndef AAA_H
#define AAA_H

#include "BBB.h"

class AAA
{ 
  BBB *bbb;
/* ... */ 
};

#else
class AAA;  //Forward declaration
#endif

//+++++++++++++++++++++++++++++++++++++++

//File BBB.h
#ifndef BBB_H
#define BBB_H

#include "AAA.h"

class BBB
{ 
  AAA *aaa;
/* ... */ 
};

#else
class BBB;  //Forward declaration
#endif

J'aimerais pour que cela soit inclus dans les IDEs que de générer automatiquement du code à partir de modèles.