Héritage multiple + mess de fonction virtuelle

J'ai un diamant à l'héritage multiple scénario comme celui-ci:

    A
  /   \
 B     C
  \   /
    D

La mère commune, Une, définit un virtuel de la fonction fn().
Est-il possible pour les deux B et C afin de définir fn()?
Si c'est le cas, la prochaine question est, pouvez D accéder à la fois aux B et C du fn() sans ambiguïté? Je suis en supposant qu'il existe certains syntaxe de cette..
Et est-il possible D faire sans connaître plus précisément, qui sont B et C? B et C peuvent être remplacées par d'autres classes et je veux le code D être générique.

Ce que je suis en train de faire est de D en quelque sorte énumérer toutes les instances du fn() il a dans son ascendance. Est-ce possible dans certains autres moyens que les fonctions virtuelles?

source d'informationauteur shoosh

  1. 18

    Sauf si vous les remplacez fn de nouveau dans Dnon, il n'est pas possible. Car il n'y a pas de finale overrider dans un D de l'objet: les Deux C et B remplacer A::fn. Vous avez plusieurs options:

    • Déposer une ou l'autre C::fn ou B::fn. Ensuite, celui qui remplacent toujours A::fn a la finale overrider.
    • Place un final overrider dans D. Alors, que l'on remplace A::fn aswell comme fn dans C et B.

    Par exemple les résultats suivants dans une erreur de compilation:

    #include <iostream>

class A {
public:
    virtual void fn() { }
};

class B : public virtual A {
public:
    virtual void fn() { }
};

class C : public virtual A {
public:
    virtual void fn() { }
};

//does not override fn!!
class D : public B, public C {
public:
    virtual void doit() {
        B::fn();
        C::fn();
    }
};

int main(int argc, char **argv) {
  D d;
  d.doit();
  return 0;
}

    Vous pouvez, toutefois dériver non virtuelle à partir de A en C et B, mais alors vous n'avez pas de diamant de l'héritage de plus. C'est, chaque membre dans Un apparaît deux fois dans B et C parce que vous avez deux Une classe de base des sous-objets dans un D objet. Je vous recommande de repenser la conception. Essayez de supprimer le double des objets comme ça qui nécessitent l'héritage virtuel. Il est souvent la cause de ce genre de situations conflictuelles.

    Un cas très similaire à cela, c'est quand vous voulez remplacer une fonction spécifique. Imaginez que vous avez une fonction virtuelle avec le même nom dans B et C (maintenant sans une base commune). Et dans D vous souhaitez remplacer chaque fonction, mais de donner un comportement différent pour chacun. Selon que vous appeler la fonction avec un B pointeur ou C pointeur, vous avez le comportement différent. L'Héritage Multiple de la Partie III par Herb Sutter explique une bonne façon de le faire. Il pourrait vous aider à vous décider sur votre conception.

  2. 4

    Première question, oui, B et C peuvent définir fn() comme une fonction virtuelle.
    Deuxièmement, D peut bien sûr l'accès B::fn() et C::fn() par l'aide de la portée de l'opérateur ::
    Troisième question: D doit au moins savoir de B et de C, puisque vous devez définir sur la liste d'héritage. Vous pouvez utiliser des modèles pour laisser les types B et C ouvert:

    class A
{
public:
   virtual ~A() {}
   virtual void fn() = 0;
};

class B: public A
{
public:
   virtual ~B() {}
   virtual void fn(){ std::cout << "B::fn()" << std::endl; }
};

class C: public A
{
public:
   virtual ~C() {}
   virtual void fn(){ std::cout << "C::fn()" << std::endl; }
};

template <typename TypeB, typename TypeC>
class D: public TypeB, public TypeC
{
public:
   void Do()
   {
      static_cast<TypeB*>(this)->fn();
      static_cast<TypeC*>(this)->fn();
   }
};

typedef D<B, C> DInst;

DInst d;
d.Do();

    Sur le souhait automatiquement les énumérer tous fn() les fonctions de toutes les classes qui hérite D: je ne suis pas sûr si c'est possible sans avoir recours à la licence MPL. Au moins, vous pouvez étendre mon exemple ci-dessus avec les versions qui traitent de 3 et plus de paramètres de modèle, mais je pense qu'il y a une partie supérieure (interne par le compilateur)limite du nombre de classe de paramètres du modèle.

  3. 1

    Il y a déjà plusieurs questions qui traitent de ce. Semble que nous sommes à court de questions à poser. Peut-être la boîte de recherche doit être plus grand que l'Poser une Question bouton.

    Voir

  4. 1

    Vous ne pouvez pas vous énumérer les définitions de fn() dans l'ascendance. C++ manque de réflexion. La seule façon que je peux imaginer est un géant de tests de boucle de la typeid de tous les ancêtres possibles. Et ça fait mal à l'imaginer.

  5. 1

    Vous voudrez peut-être regarder à Loki TypeLists si vous avez vraiment besoin pour être en mesure de retracer les ancêtres et énumérer les types. Je ne suis pas sûr si ce que vous demandez est vraiment possible sans un tas de travail. Assurez-vous que vous n'êtes pas sur de génie ici.

    Sur une note un peu différente, si vous allez utiliser, à MI de cette manière (c'est à dire, la redoutable diamant), vous devez être très explicite au sujet de qui virtuel membre que vous souhaitez. Je ne peux pas penser à une bonne cas où vous voulez choisir la sémantique de B::fn() sur C::fn() sans explicitement de prendre une décision lors de l'écriture de D. Vous aurez probablement choisir l'un sur l'autre (ou même les deux) sur base de ce que la méthode individuelle. Une fois que vous avez pris une décision, la condition est que les changements héréditaires de ne pas modifier les attentes ou sémantique de l'interface.

    Si vous êtes vraiment inquiet à propos de la permutation dans une nouvelle classe, dire E à la place de dire B où E ne descend pas de B mais offre la même interface, alors vous devriez vraiment utiliser le modèle de l'approche si je ne suis pas sûr de savoir pourquoi il y a un static_cast<> là...

    struct A {
    virtual ~A() {}
    virtual void f() = 0;
};
struct B: A {
    virtual void f() { std::cout << "B::f()" << std::endl; }
};
struct C: A {
    virtual void f() { std::cout << "C::f()" << std::endl; }
};

template <typename Base1, typename Base2>
struct D: Base1, Base2 {
    void g() { Base1::f(); Base2::f(); }
};

int main() {
    D<B,C> d1;
    D<C,B> d2;
    d1.g();
    d2.g();
    return 0;
}

//Outputs:
//  B::f()
//  C::f()
//  C::f()
//  B::f()

    fonctionne très bien et semble un peu plus facile à regarder.

  6. 0

    Vividos a déjà répondu à la partie principale de la poste. Même si je voudrais utiliser le champ d'application de l'opérateur au lieu de les plus lourdes static_cast<> + de l'opérateur de déréférencement.

    En fonction de la tâche à portée de main, peut-être vous pouvez modifier la relation d'héritage (de D à B et C pour les moins de couplage composition (plus éventuellement, l'héritage d'Un). C'est en supposant que vous n'avez pas besoin D être utilisé polimorphically que B ou C, et que vous n'avez pas vraiment besoin de B et C le partage de la même base instance.

    Si vous optez pour la composition, vous pouvez recevoir le B et C comme arguments à votre constructeur comme références/pointeurs de type A, prise D ignorer complètement les types B et C. a ce stade, vous pouvez utiliser un conteneur pour que de nombreux objets dérivés. Votre propre mise en œuvre de la fn() (si vous le décidez) ou toute autre méthode.