c++ fichiers d'en-tête, y compris mutuellement

Vous ne pouvez pas avoir chaque classe ont "un champ qui est le type de classe", qui serait une définition récursive et non seulement le compilateur ne sera pas en mesure de faire tout le sens, il n'a même pas de sens logique.

Chaque classe a un champ qui est le type de l'autre classe est le genre de l'impossibilité que l'on ne voit dans M. C. Escher des dessins ou des animations de celle-ci, comme celui-ci:

 

                                           

                 B. de Smit et H. W. Lenstra - Source: escherdroste.math.leidenuniv.nl

                     basé sur Escher "Imprimer Galerie" Lithographie, 1956, voir Wikipedia

 

L'un des deux champs devront être pointeur, de manière à briser les récursive de confinement, et d'éviter la logique de l'impossibilité.

Qui nous amène au problème suivant: si la classe B est de contenir une instance de la classe A, alors, évidemment, doit être déclarée avant la classe B, de sorte que l'Un est déjà connu du compilateur lors de la compilation de B. Mais si la classe A est déclarée avant la classe B, comment peut-on déclarer un pointeur vers un point B en Un? La classe B n'est pas encore connu au moment de l'est compilé! La réponse à cette question est un spécial construire connu comme avant la déclaration de qui existe précisément pour tenir compte des situations de ce genre. Avant la déclaration de la classe B ressemble à ceci:

class B;

Tout, c'est de dire au compilateur qu'il y aura une classe appelée B. Il n'a pas d'indiquer au compilateur rien sur le contenu de la classe B, il y a très peu de choses que nous pouvons faire avec elle, mais nous pouvons faire une chose: déclarer des pointeurs vers B.

Donc, la solution complète pour le problème ressemble à ceci:

fichier "A. h":

/* This is called a "forward declaration".  We use it to tell the compiler that the 
   identifier "B" will from now on stand for a class, and this class will be defined 
   later.  We will not be able to make any use of "B" before it has been defined, but 
   we will at least be able to declare pointers to it. */
class B;

class A
{
    /* We cannot have a field of type "B" here, because it has not been defined yet. 
       However, with the forward declaration we have told the compiler that "B" is a 
       class, so we can at least have a field which is a pointer to "B". */
    B* pb; 
}

fichier "B. h":

#include "A.h"

class B
{
   /* the compiler now knows the size of "A", so we can have a field of type "A". */
   A a;
}

Je sais que c'est un vieux sujet, mais peut-être que vous êtes toujours intéressé à la solution!

Fait en C++, vous pouvez utiliser deux classes de façon récursive sans l'aide de pointeurs et voici comment le faire.

de fichiers: un.h

#include <b.h>

class A {
    B<> b;
}

fichier: b.h

class A;

template<typename T = A>
class B {
    T a;
}

fichier: main.cpp

#include "a.h"    
A a;

et c'est tout!

bien sûr, c'est juste par curiosité 🙂

Si B ne peut exister que dans Une, il me semble être capable de créer de A et B sans l'aide d'un pointeur. B a simplement déclarer avant Un et de ne pas l'inclure (en évitant le récursive de l'inclusion).

Dans mon cas, un Document a un Section qui obtient une référence à son Document.

section.h

class Document;

class Section
{
    public:
        Section(Document& document) : document{document} {} 
    private:
        Document& document;
};

document.h

#include "section.h"

class Document
{
    public:
        Document() : section{*this} {}
    private:
        Section section;
};

main.cpp

#include "document.h"

int main()
{
    Document document{};
}

Ce code compile avec g++ et fonctionne sur Linux.

Un (complexe) de l'ensemble des ifdef peut l'activer pour les autres cas, mais je ne suis pas sûr à propos de la lisibilité...