C'è un modo per inoltrare la dichiarazione di covarianza?

Question

Supponiamo che io sono queste classi astratte Foo e Bar:

class Foo; 
class Bar; 

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

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

Supponiamo inoltre che ho la classe derivata ConcreteFoo e ConcreteBar. Voglio perfezionare covariantly il tipo di ritorno dei foo() e bar() metodi come questo:

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

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

Questo non verrà compilato dal nostro amato compilatore unico passaggio non sa che ConcreteBar erediterà da Bar, e in modo che sia ConcreteBar un tipo di ritorno covariante perfettamente legale. La semplice dichiarazione in avanti ConcreteBar non funziona, poiché non dice al compilatore nulla sull'ereditarietà.

Si tratta di un problema di C++ con cui dovrò convivere o esiste un modo per aggirare questo dilemma?

Answer 1

È possibile simularlo facilmente, ma si perde il controllo di tipo statico. Se si sostituisce il dynamic_casts da static_casts, è avere quello che il compilatore sta usando internamente, ma non avete dinamica né statica Tipo controllo:

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

covarianza si basa sullo schema di successione, quindi dal momento che non è possibile dichiarare

class ConcreteBar : public Bar; 

quindi non c'è modo di dire al compilatore della covarianza.

Ma si può fare con l'aiuto di modelli, dichiarano ConcretFoo :: bar come modello e di delimitazione in seguito consente di risolvere questo problema

Answer 3

Non polimorfismo statico risolto il problema? Alimentazione della classe base con la classe derivata tramite argomento modello? Quindi la classe base conoscerà il tipo derivativo e dichiarerà un virtuale appropriato?

Answer 4

Che ne dici di questo.

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(); 
};