Kovaryans bildirmek için bir yol var mı?

Question

Bu soyut sınıflarım Foo ve Bar olduğunu varsayalım:

class Foo; 
class Bar; 

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

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

Daha ileride ConcreteFoo ve ConcreteBar türetilmiş sınıflara sahip olduğumu varsayalım. Xzx43 ve bar() yöntemlerinin dönüş türünü kovaryant olarak düzeltmek istiyorum:

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

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

Bu bizim sevgili tek geçişli derleyicimizin ConcreteBarBar'dan miras alacağını bilmediğinden Mükemmel bir yasal kovaryant dönüş tipi. Düz bir şekilde ConcreteBar bildirme işlemi, derleyiciye mirasla ilgili bir şey söylemediğinden çalışmaz.

Bu C++ 'nın bir eksikliği mi Yaşanacağım yoksa bu ikilemin etrafında bir yol var mı?

Answer 1

Oldukça kolay bir şekilde sahte olabilirsiniz, ancak statik tip denetimini kaybedersiniz. Eğer static_casts tarafından dynamic_casts değiştirirseniz, derleyici dahili olarak hangisini kullandığına var, ama hiçbir dinamik ne de statik tip kontrolünden: Eğer ilan edemeyeceğini beri çok

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

Kovaryans, kalıtım şemasına dayanmaktadır

class ConcreteBar : public Bar; 

Bu nedenle derleyiciye kovaryans hakkında bilgi vermenin yolu yoktur.

Ama şablonlar yardımıyla bunu yapabilir, şablon ve sonraki sınırlayıcı statik polimorfizmi sorununuzu çözmez mu bu sorunu

Answer 3

çözmek verir ConcretFoo :: çubuğu olarak beyan? Temel sınıfı şablon argümanı aracılığıyla türetilmiş sınıfla beslemek? Yani temel sınıf türevi türünü bilecek ve uygun bir sanal bildirecek?

Answer 4

Buna ne dersiniz?

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