C++ 模板继承问题（警告和错误）

Question

我正在尝试模仿 C++ 中通用列表的 .Net 实现。

我将各种 interfaces 充实为纯虚拟抽象类，如下所示：

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;

};

现在，当我尝试如下实现我的主要 List 类时：

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...

只要我尝试如下使用List<T> 类：

List<int32_t> myList;

出现警告：

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> {
       ^

随后出现以下错误：

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> > >}'

如果我修改List<T> 类的声明以删除IList<T> 和ICollection<T> 抽象类，则不会产生错误。

我猜我使用模板化基类的方式在这种情况下是不正确的。

Answer 1

此问题与模板没有直接关系。

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!
}

当你继承一个类时，派生类包含一个基类的对象，称为基类子对象。所以在我的例子中，每个B 都包含一个A。每个C 都包含一个A 和一个B。问题是，当我尝试将f 作为C 的成员调用时，编译器需要找到A 子对象来调用它。但是有两个具有这种类型的子对象！一个是直接被C继承的，一个是在继承的B子对象里面。所以编译器无法理解我的意思。

在这种情况下的解决方案是不要继承一个类两次。在我的示例中，C 不需要直接继承 A，因为继承 B 将为它提供间接的 A 子对象并访问其所有成员。

在您的情况下，List<T> 不需要直接继承 ICollection<T>。从IList<T> 派生就足够了。

(在其他情况下，使用“虚拟继承”可能很有用，它告诉编译器“只为这种类型创建一个基类子对象，即使我在某个派生类中多次间接继承它”。但是就目前的情况而言，这对于您的代码来说可能是多余的。）