¿Hay alguna manera de reenviar declarar covarianza?

Question

Supongamos que tengo estas clases abstractas y FooBar:

class Foo; 
class Bar; 

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

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

Supongamos, además, que tengo la clase derivada ConcreteFoo y ConcreteBar. Quiero afinar covariantly el tipo de retorno de los foo()bar() y métodos como éste:

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

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

Esto no se compilará ya nuestro querido compilador de una sola pasada no sabe que ConcreteBar heredarán de Bar, y por lo que es ConcreteBar un tipo de devolución covariante perfectamente legal. Simple forward declarar ConcreteBar tampoco funciona, ya que no le dice nada al compilador sobre la herencia.

¿Esto es una deficiencia de C++ tendré que vivir o hay realmente una manera de evitar este dilema?

Answer 1

Puede falsificarlo con bastante facilidad, pero pierde la comprobación del tipo estático. Si reemplaza el dynamic_casts por static_casts, tiene lo que el compilador está utilizando internamente, pero no tiene cheque tipo dinámico ni estático:

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 se basa en diagrama de herencia, por lo que ya no se puede declarar

class ConcreteBar : public Bar; 

por lo tanto, no hay manera de decirle al compilador sobre la covarianza.

Pero se puede hacer con ayuda de plantillas, declaran ConcretFoo :: bar como plantilla y después de delimitación permite a solucionar este problema

Answer 3

No polimorfismo estática a resolver su problema? Alimentando la clase base con la clase derivada a través del argumento de plantilla? Entonces, ¿la clase base sabrá el Tipo derivado y declarará un virtual apropiado?

Answer 4

Qué tal esto.

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