Existe-t-il un moyen de transmettre la covariance?

Question

Supposons que j'ai ces classes abstraites Foo et Bar:

class Foo; 
class Bar; 

class Foo 
{ 
public: 
    virtual Bar* bar() = 0; 
}; 

class Bar 
{ 
public: 
    virtual Foo* foo() = 0; 
}; 

On suppose en outre que j'ai la classe dérivée ConcreteFoo et ConcreteBar. Je veux raffiner covariante le type de retour des méthodes foo() et bar() comme ceci:

class ConcreteFoo : public Foo 
{ 
public: 
    ConcreteBar* bar(); 
}; 

class ConcreteBar : public Bar 
{ 
public: 
    ConcreteFoo* foo(); 
}; 

Ce ne sera pas compilé depuis notre bien-aimé compilateur monopasse ne sait pas que ConcreteBar va hériter de Bar, et que ConcreteBar est un type de retour covariant parfaitement légal. Plain avant déclarant ConcreteBar ne fonctionne pas non plus, car il ne dit rien au compilateur sur l'héritage.

Est-ce une lacune de C++ avec laquelle je devrai vivre ou y a-t-il un moyen de contourner ce dilemme?

Answer 1

Vous pouvez simuler assez facilement, mais vous perdez la vérification de type statique. Si vous remplacez la dynamic_casts par static_casts, vous avez ce que le compilateur utilise en interne, mais vous avez pas de vérification de type dynamique ni statique:

class Foo; 
class Bar; 

class Foo 
{ 
public: 
    Bar* bar(); 
protected: 
    virtual Bar* doBar(); 
}; 

class Bar; 
{ 
public: 
    Foo* foo(); 
public: 
    virtual Foo* doFoo(); 
}; 

inline Bar* Foo::bar() { return doBar(); } 
inline Foo* Bar::foo() { return doFoo(); } 

class ConcreteFoo; 
class ConcreteBar; 
class ConcreteFoo : public Foo 
{ 
public: 
    ConcreteBar* bar(); 
protected: 
    Bar* doBar(); 
}; 

class ConcreteBar : public Bar 
{ 
public: 
    ConcreteFoo* foo(); 
public: 
    Foo* doFoo(); 
}; 

inline ConcreteBar* ConcreteFoo::bar() { return &dynamic_cast<ConcreteBar&>(*doBar()); } 
inline ConcreteFoo* ConcreteBar::foo() { return &dynamic_cast<ConcreteFoo&>(*doFoo()); } 

Answer 2

Covariance est basé sur le diagramme d'héritage, donc, puisque vous ne pouvez pas déclarer

class ConcreteBar : public Bar; 

donc aucun moyen de dire au compilateur sur la covariance.

Mais vous pouvez le faire avec l'aide de modèles, déclarent ConcretFoo :: barre en tant que modèle et englobante plus tard, vous permet de résoudre ce problème

Answer 3

Ne polymorphisme statique résoudre votre problème? Nourrir la classe de base avec la classe dérivée via l'argument template? Donc, la classe de base connaîtra le type dérivé et déclarera un vrai virtuel?

Answer 4

Que diriez-vous de ceci.

template <class BarType> 
class Foo 
{ 
public: 
    virtual BarType* bar() = 0; 
}; 

template <class FooType> 
class Bar 
{ 
public: 
    virtual FooType* foo() = 0; 
}; 

class ConcreteBar; 
class ConcreteFoo : public Foo<ConcreteBar> 
{ 
public: 
    ConcreteBar* bar(); 
}; 

class ConcreteBar : public Bar<ConcreteFoo> 
{ 
public: 
    ConcreteFoo* foo(); 
};