Quelle est la meilleure façon de traiter avec les co-dépendante de classes en C++?

Dire que j'ai une classe foo avec un objet de la classe bar en tant que membre

class foo
{
    bar m_bar;
};

Supposons maintenant que la barre de besoin de garder une trace de la foo qui le possède

class bar
{
    foo * m_pfoo;
}

Les deux classes de référence les uns des autres et sans une déclaration anticipée, ne compilera pas. Ainsi, l'ajout de cette ligne avant de foo déclaration résout ce problème

class bar;

Maintenant, ici, est le problème - lors de l'écriture des fichiers d'en-tête, chaque en-tête dépend de l'autre: foo.h a besoin de définitions de la barre.h et vice-versa. Quelle est la bonne façon de traiter ce?

OriginalL'auteur Nathan Osman | 2010-01-27

  1. 24

    Vous devez déplacer tous les accès des membres de l'en-tête, et dans vos fichiers source.

    De cette façon, vous pouvez déclarer avant vos classes dans l'en-tête, et de le définir dans foo:

    //foo.h
class bar;

class foo {
    bar * m_pbar;
}

//bar.h
class foo;
class bar {
    foo * parent;
}

    Qui va vous permettre de travailler, vous ne pouvez pas mettre les définitions qui nécessitent des informations de membre dans votre tête de le déplacer à l' .fichier cpp. L' .fichiers cpp peut inclure à la fois foo.h et au bar.h:

    //Foo.cpp
#include "foo.h"
#Include "bar.h"

void foo::some_method() {
     this->m_pbar->do_something(); //Legal, now, since both headers have been included
}
    Cela semble être la meilleure option pour ce dont j'ai besoin.
    maintenant, comment fonctionne cette solution de travail si votre co-dépendant classes sont basées sur des modèles, et ne peut donc pas être séparés en en-tête et les fichiers cpp?

    OriginalL'auteur Reed Copsey

  2. 2

    Je suppose, une façon est de faire abstraction de classes d'interface avec les non membres. Puis une sous-classe foo et bar à partir de ces classes d'interface.

    par exemple:

    class FooInterface
{
   //methods here
}

class BarInterface
{
   //methods here
}

class Foo : public FooInterface
{
   BarInterface *pBar;
}

class Bar : public BarInterface
{
   FooInterface *pFoo;
}

    Cette brise le cycle de dépendances (à moins que les interfaces elles-mêmes dépendent les uns des autres, et si c'est le cas, alors ils devraient probablement être déclaré dans le même fichier)

    OriginalL'auteur Jason S

  3. 1

    Dans votre exemple, foo dépend bar (car il contient une réelle bar objet), mais bar ne dépend pas de foo (puisqu'il ne contient qu'un foo *). Maintenant bar ne dépendent sur foo être un nom de type, de sorte que la barre.h a besoin d'une déclaration anticipée du nom: class foo;. foo dépend bar, donc foo.h doit contenir #include "bar.h"

    Vous ne pouvez pas avoir des classes qui dépendent directement les uns les autres en C++, il n'a tout simplement pas de travail. Vous avez besoin de dissocier les classes de telle sorte que l'on ne dépend que de l'autre, comme dans votre exemple. Les seules choses qui créent une dépendance directe sont à l'aide d'une classe comme une classe de base ou comme un champ; toute autre utilisation crée une dépendance indirecte, qui n'est généralement pas un problème.

    OriginalL'auteur Chris Dodd

  4. 0

    Autant que je sache, la seule véritable façon de le faire est en utilisant les pointeurs, car ils ne nécessitent pas de définition de la classe jusqu'à ce que l'unité de traduction (.rpc) et dans ce cas les deux classes ont été définies correctement.

    OriginalL'auteur Nick Bedford