Czy istnieje sposób przekazania do przodu zadeklarowania kowariancji?

Question

Załóżmy, że mam tych klas abstrakcyjnych Foo i Bar:

class Foo; 
class Bar; 

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

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

Załóżmy ponadto, że mam klasę pochodną ConcreteFoo i ConcreteBar. Chcę covariantly udoskonalić typ Powrót foo()bar() metod i tak:

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

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

Nie będzie to skompilować od naszego ukochanego towarzysza pojedynczy kompilator nie wie, że ConcreteBar będzie dziedziczyć Bar, i tak jest, że ConcreteBar całkowicie legalny kowariantowy typ zwrotu. Zwykłe forwardowanie deklaracji ConcreteBar również nie działa, ponieważ nie informuje kompilatora o dziedziczeniu.

Czy to jest niedociągnięcie C++, z którym będę musiał żyć, czy też rzeczywiście istnieje sposób obejścia tego dylematu?

Answer 1

Możesz go łatwo sfałszować, ale stracisz kontrolę typu statycznego. Jeśli zastąpić dynamic_casts przez static_casts, masz co kompilator używa wewnętrznie, ale nie masz dynamiczny ani statycznej kontroli typu:

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

kowariancji jest oparty na schemacie spadkowego, więc skoro nie można zadeklarować

class ConcreteBar : public Bar; 

dlatego nie można powiedzieć kompilatorowi o kowariancji.

Ale można to zrobić przy pomocy szablonów, oświadczam ConcretFoo :: bar jako szablon i później ograniczający pozwala rozwiązać ten problem

Answer 3

Nie Polimorfizm statycznych w rozwiązaniu problemu? Karmienie klasy bazowej klasą pochodną za pomocą argumentu szablonu? Zatem klasa podstawowa będzie znała rodzaj pochodnej i zadeklarowała właściwą wirtualną?

Answer 4

Co powiesz na to.

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