帶接口對象的C++模板

Question

我有下面的代碼不能編譯。

class Base { 
    public: 
     virtual ~Base() { }; 
}; 

class Derived : public Base { }; 

class NotDerived { }; 

template <typename T> 
class Group { }; 

int main() { 
    Group<Base> *g = NULL; 

    g = new Group<Base>();  // Works 
    g = new Group<Derived>(); // Error, but I want it to work 

    g = new Group<NotDerived>(); // Error, as expected 
} 

我明白，這不能編譯，因爲g是不同的類型Group<Derived>。爲了在Java中完成這項工作，我會做一些事情，例如Group<? extends Base> g，但據我所知C++沒有那個關鍵字。可以做什麼？

編輯：我想澄清一下，我不希望它有可能將Base的類型設置爲g。我已經更新了我的例子來解釋這一點。

編輯2：我的問題有兩種解決方案。 Dave's我發現很簡單，很容易定義。但Bowie's（加上Mark's）更適合我的需求。

Answer 1

你可以讓集團<數據庫>基類的所有<集團T> T！=基地。

class Base { 
    public: 
     virtual ~Base() { }; 
}; 

class Derived : public Base { }; 


template <typename T> class Group; 

struct Empty { }; 

template <typename T> 
struct base_for_group_t { 
    typedef Group<Base> type; 
}; 

template <> 
struct base_for_group_t<Base> { 
    typedef Empty type; 
}; 

template <typename T> 
class Group : public base_for_group_t<T>::type { }; 

int main() { 
    Group<Base> *g = 0; 

    g = new Group<Base>(); // Works 
    g = new Group<Derived>(); // now works 
} 

Answer 2

我不認爲C++支持。 C++ Template在編譯時完全處理，因此它不支持多態性。這意味着模板參數的類型應該對賦值表達式的兩側完全相同。

Answer 3

C++模板和java泛型非常不同，像一個正方形和一個圓形。一個生成代碼，另一個驗證在運行時類型將工作並匹配一個通用代碼塊。非常簡單。

What are the differences between "generic" types in C++ and Java?

Answer 4

的類Group<Base>和Group<Derived>是完全不相關的，不同的類。指向他們的方向不可轉換。

如果你需要運行時多態性的行爲，你的類模板Group可以從普通（非模板）基類派生：

class Group // base 
{ 
    virtual ~Group() { } 
}; 

template <typename T> 
class ConcreteGroup : public Group 
{ 
    // ... 
    T * m_impl; 
}; 

Group * g1 = new ConcreteGroup<A>; 
Group * g1 = new ConcreteGroup<B>; 

Answer 5

Bowie Owens's Answer處理您需要解決原始問題的協方差。至於你在編輯問題中所要求的限制 - 你可以通過使用類型特徵來實現。

template <typename T, class Enable = void> class Group; 

template <typename T> 
class Group<T, typename enable_if<is_base_of<Base, T>::value>::type> 
    : public base_for_group_t<T>::type { }; 

Answer 6

我想我明白你要做什麼。我不確定這是最好的方法（你可能想看看Boost.Factory）。

template <class T> 
class Factory { 

public: 
    virtual T* operator()() = 0; 
}; 

template <class Derived, class Base> 
class ConcreteFactory : public Factory<Base> { 

public: 
    virtual Base* operator()() { 
    return new Derived(); 
    } 
}; 

class Base { 
public: 
    virtual ~Base() {}; 
}; 

class Derived1 : public Base { }; 
class Derived2: public Base {}; 

class NotDerived {}; 

int main() 
{ 
    Factory<Base>* g; 

    g = new ConcreteFactory<Derived1, Base>; 
    g = new ConcreteFactory<Derived2, Base>; 
    // g = new ConcreteFactory<NotDerived, Base>; // Will not work if you try to do this 
}