Problèmes d'héritage de modèle C++ (avertissements et erreurs)

Question

J'essaie d'imiter l'implémentation .Net d'une liste générique en C++. Dès

template <typename T> 
class List : public IList<T>, public ICollection<T> { 

public: 
    List(void); 
    List(int32_ capacity); 

    // ICollection<T> 
    void Add(T item); 
    // other functions from ICollection 

    // IList<T> 
    T Item(int32_t index); 
    // other functions from IList 

    void AddRange(IList<T> items); 

private: 
    typedef vector<T> ListType; 

    ListType *m_pList; 
}; 


template <typename T> 
List<T>::List(void) { 
    m_pList = new ListType(); 
} 

template <typename T> 
void List<T>::Insert(uint32_t index, T item) { 
    // Insert an entry into the list at the specified offset 
    m_list->insert(index, item); 
} 

// Implementation of other functions here... 

comme:

J'ai étoffé les différentes classes abstraites virtuels comme purement interfaces comme suit:

template <typename T> 
class ICollection { 

public: 
    virtual void Add(T item) = 0; 
    virtual void Clear(void) = 0; 
    virtual bool Contains(T item) = 0; 
    virtual void Remove(T item) = 0; 

    virtual int32_t Count(void) const = 0; 

}; 

template <typename T> 
class IList : public ICollection<T> { 

public: 
    virtual T Item(int32_t index) = 0; 
    virtual int32_t IndexOf(T item) = 0; 
    virtual void Insert(int32_t index, T item) = 0; 
    virtual void RemoveAt(int32_t index) = 0; 

}; 

Maintenant, lorsque je tente de mettre en œuvre ma classe principale List comme suit J'essaie d'utiliser la classe List<T> comme suit:

List<int32_t> myList; 

Un avertissement se disant:

In instantiation of 'class List<long int>': 
    required from here 
warning: direct base 'ICollection<long int>' inaccessible in 'List<long int>' due to ambiguity [enabled by default] 

class List : public IList<T>, public ICollection<T> { 
    ^

Suivi par l'erreur suivante:

In instantiation of 'void List<T>::Insert(uint32_t, T) [with T = long int; uint32_t = long unsigned int]': 
    required from here 
error: no matching function for call to 'std::vector<long int, std::allocator<long int> >::insert(uint32_t&, long int&)' 

m_list->insert(index, item); 
^ 

note: std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::insert(std::vector<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = long int; _Alloc = std::allocator<long int>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<long int*, std::vector<long int, std::allocator<long int> > >; typename std::_Vector_base<_Tp, _Alloc>::pointer = long int*; std::vector<_Tp, _Alloc>::value_type = long int] 

vector<_Tp, _Alloc>:: 
^ 

note: no known conversion for argument 1 from 'uint32_t {aka long unsigned int}' to 'std::vector<long int, std::allocator<long int> >::iterator {aka __gnu_cxx::__normal_iterator<long int*, std::vector<long int, std::allocator<long int> > >}' 

Si je modifie la déclaration de la classe List<T> de façon à éliminer les classes abstraites IList<T> et ICollection<T>, aucune erreur ne généré.

Je devine que la façon dont j'utilise les classes de base modélisées n'est pas correcte dans ce cas.

Answer 1

Ce problème n'est pas directement lié aux modèles.

class A { 
    public void f() {} 
}; 

class B : public A {}; 

class C : public A, public B {}; 

int main() { 
    C c; 
    c.f(); // Error: ambiguous base class! 
} 

Lorsque vous héritez d'une classe, la classe dérivée contient un objet pour la classe de base, appelée une classe de base sous-objet. Donc, dans mon exemple, chaque B contient un A. Et chaque C contient un A et un B. Le problème est que lorsque j'essaie d'appeler f en tant que membre de C, le compilateur doit trouver le sous-objet A pour l'appeler. Mais il y a deux sous-objets avec ce type! L'un est directement hérité par C, et l'autre est à l'intérieur du sous-objet B hérité. Le compilateur ne peut donc pas comprendre ce que je veux dire.

La solution dans ce cas est de ne pas hériter deux fois d'une classe. Dans mon exemple, C n'a pas besoin d'hériter directement A, puisque l'héritage B lui fournira un sous-objet indirect A et un accès à tous ses membres. Dans votre cas, List<T> n'a pas besoin d'hériter directement de ICollection<T>. Il suffit juste de dériver de IList<T>. (Dans d'autres cas, il peut être utile d'utiliser "l'héritage virtuel", qui dit au compilateur "de ne créer qu'un sous-objet de classe de base pour ce type, même si je l'hérite indirectement plus d'une fois dans une classe dérivée". Mais cela peut être exagéré pour votre code tel quel.)