deux classes contiennent des objets les uns des autres

Question

J'espère qu'il y a une réponse simple à cela. sans devenir trop compliqué j'ai deux classes. un "animal" et une "cellule" La cellule contient un animal en tant que membre. Animal a des méthodes qui acceptent les cellules dans leurs paramètres.

Je suis juste confus quant à la façon dont i #include chaque classe l'en-tête des autres? Je n'ai jamais eu qu'à monter une chaîne de classes et j'ai juste inclus l'en-tête de la dernière classe dans la suivante et ainsi de suite, mais cette situation circulaire m'a un peu perdu.

J'espère que cela a du sens, toute aide grandement appréciée.

Answer 1

Vous pouvez utiliser des déclarations directes pour résoudre le problème des références circulaires.

Exemple:

//animal.h 

#include "cell.h" 

class Animal { 
public: 
    void foo (Cell cell); 
} 

// cell.h 

class Animal; // forward declaration 

class Cell { 
private: 
    Animal * m_animal; // pointer to Animal object 
} 

Answer 2

Les dépendances cycliques sont gérées avec forward declarations (défilez vers le bas de la page).

Answer 3

Vous devez renvoyer une des classes pour que le compilateur soit au courant. Un peu comme, il y a cette classe "Animal", je vais vous dire ce que c'est plus tard.

Exemple:

class Animal; 

class Cell 
{ 
    Animal *a; 
}; 

class Animal 
{ 
    Cell *c; 
}; 

Comme Gareth note dans les commentaires, vous ne pouvez pas déclarer avant quelque chose qui sera passé par valeur. C'est parce que le compilateur ne peut traiter qu'avec des types dont il connaît la taille. Un pointeur vers n'importe quoi a toujours la même taille, donc le compilateur nécessite que Animal soit entièrement défini dans l'exemple ci-dessus.

Cela ne fonctionnera pas:

class Animal; 

class Cell 
{ 
    Animal a; // compiler needs to know how Animal is defined 
}    // and so will fail at this point 

Answer 4

Si Cell contient Animal en tant que membre puis une définition complète de Animal est nécessaire avant Cell est définie de sorte que vous devrez #include l'en-tête qui définit Animal de l'en-tête définit Cell.

#include "animal.h" 

class Cell 
{ 
    // ... 
    Animal animal; // animal member 
}; 

Si Animal a des méthodes qui prennent ou retournent un Cell (que ce soit par référence ou valeur) alors vous pouvez juste avant de déclarer Cell avant la définition de Animal comme celui-ci.

// animal.h 
class Cell; 

class Animal 
{ 
    // declarations of Animal methods 
}; 

Answer 5

Il est impossible pour deux classes chacun pour contenir des objets de l'autre type de - un ou les deux des classes devra contenir un pointeur vers le type de l'autre.

Answer 6

animal.h:

class Cell; // fwd declaration 

// Cell is now an "incomplete type" 

class Animal { 
    void Respirate(Cell &); // reference: no need for complete type 
}; 

cellule

.h:

OU

class Animal 

class Cell { 
    Animal *organism; // Cell "knows about an" animal rather than "has an" 
}; 

Answer 7

Vous pouvez envoyer déclarer, mais cela ne résout pas complètement le problème, il vous permet de ne déclarer un pointeur à cet objet, ne pas utiliser les fonctions/membres à l'intérieur cet objet. Vous pouvez le faire:

Animal.h

class Cell; 

class Animal { 
    private: 
    Cell cell; 
}; 

Animal.cpp

#include "Animal.h" 
#include "Cell.h" 

// Animal functions can use members/functions in Cell object here 

Cell.h

class Animal; 

class Cell 
{ 
    private: 
    Animal animal; 
}; 

Cell.cpp

#include "Animal.h" 
#include "Cell.h" 

// Cell functions can use members/functions in Animal object here 

De cette façon les deux objets peuvent utiliser complètement les fonctionnalités de l'autre (sauf dans les en-têtes, mais ça va)