Question

template <typename T>
class BaseQueue
{
    public :
    virtual void push_back(T value) = 0;
    //other  virtual methods
};

template <typename T>
class BaseDeque: public virtual BaseQueue<T>
{
    public:
        virtual void push_front(T value) = 0;
        //other virtual methods
};

//Realisation
template <typename T>
class VectorQueue: public BaseQueue<T>
{
    typedef typename std::vector<T> array;
    private: array adata;
    public:
    VectorQueue()
    {
       adata = array();
    }

    void push_back(T value)
    {
        adata.push_back(value);
    }
};

template <typename T>
class VectorDeque: virtual public VectorQueue<T>, virtual protected BaseDeque<T>//, 
{
    void push_front(T value)
    {
        VectorQueue::adata.push_front(value);
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    VectorDeque<int> vd = VectorDeque<int>();//here is a error

    int i;
    std::cin >> i;
    return 0;
}

我有这样的错误：“C2259：'VectorDeque'：无法实例化抽象类......”。我该如何解决？ VectorQueue类已经实现了BaseQueue类的每个虚方法。但是编译器不知道它。我看到的唯一方法是写这样的东西：

template <typename T>
class VectorDeque: virtual public VectorQueue<T>, virtual protected BaseDeque<T>//, 
{
    void push_front(T value)
    {
        VectorQueue::adata.push_front(value);
    }
    void push_back(T value)
    {
        VectorQueue::push_back(value);
    }
    //repeat it fo every virtual method of BaseQueue class (interface)
};

但是太可怕了。

Answer 1

来自push_back的

BaseQueue未在继承链的BaseDeque侧实现，因此最少的类仍然是抽象的。

我认为你在这里强迫一个不应该存在的阶级关系。请注意标准库deque和vector中的不同容器类型和queue之类的东西如何使这些容器适应非常精确的接口而不是尝试继承。

Answer 2

即使您解决了钻石问题（或遵循@Mark B的建议并将其分开），您还有其他一些问题：

template <typename T>
class VectorQueue: public BaseQueue<T>
{
    typedef typename std::vector<T> array;
    private: array adata;   // if this is private, VectorDeque can't reach it

    public:
    // constructors have an initializer section
    // member variables should be initialized there, not in the body
    VectorQueue()
    // : adata()  // however, no need to explicitly call default constructor
    {
       // adata = array();
    }
};


template <typename T>
class VectorDeque: virtual public VectorQueue<T>, virtual protected BaseDeque<T>
{
    void push_front(T value)
    {
        // if adata is protected, you can just access it.  No need for scoping
        /*VectorQueue::*/  adata.push_front(value);
        // Error:  std::vector doesn't have a method push_front.
        // Perhaps you meant to use std::list?
    }
};

Answer 3

多重继承和静态多态有用，例如：

// Abstract bases
template <typename T, typename Val> 
class BaseQueue 
{     
public :     
    void push_back(Val val)
    {
        static_cast<T*>(this)->push_back(val); 
    }
    // ...
};  
template <typename T, typename Val> 
class BaseDeque
{     
public:         
    void push_front(Val val)
    {
        static_cast<T*>(this)->push_front(val); 
    }
    // ...
};

// Concrete class
#include <deque>
template <typename Val> 
class QueueDeque: 
    public BaseQueue<QueueDeque<Val>, Val>,
    public BaseDeque<QueueDeque<Val>, Val>
{   
    std::deque<Val> vals;
public:
    void push_front(Val val)
    {
        vals.push_front(val); 
    }
    void push_back(Val val)
    {
        vals.push_back(val); 
    }
    // etc..
};  
int main() 
{     
    QueueDeque<int> vd;// no more error      
    vd.push_front(5);
    vd.push_back(0);
    return 0; 
}

C ++界面风格编程。需要出路

3 个答案: