我想写一个双端循环队列，为了减少代码的重复使用，我决定继承循环队列，但是编译器却出现了如下问题，
以下是我的实现代码，请帮我看一下我哪里出了问题：

include

using namespace std;
template
class SeqQueue{
private:
T* elements; //存放队列元素的数组
int rear,front; //队尾指针和对头指针
int maxSize; //队列可容纳的最大元素个数
public:
SeqQueue(int sz); //构造函数
~ SeqQueue(){ delete[]elements;} //析构函数
bool EnQueue(const T& x); //进队函数
bool DeQueue(T& x); //出队函数
bool getFront(T& x); //取队头元素
void makeEmpty(){front=rear=0;} //把队置空
bool isEmpty(){return (front==rear)?true:false;} //判断队空
bool isFull(){return ((rear+1)%maxSize==front)?true:false;} //判断队满
int getSize(){return (rear-front+maxSize)%maxSize;} //求队中元素个数
friend ostream& operator<<(ostream& ostr,SeqQueue& Q); //输出运算符重载
};
template
SeqQueue::SeqQueue(int sz):rear(0),front(0),maxSize(sz){
elements=new T[maxSize];
assert(elements!=NULL); //断言机制：如果不满足括号内条件将终止程序的执行
}
template
bool SeqQueue::EnQueue(const T& x){
if(isFull()) return false;
else
elements[rear]=x;
rear=(rear+1)%maxSize; //加一再取余是为了rear指向队列最后一个元素（下标maxSize-1），再进一下标就到了0
return true;
}
template
bool SeqQueue::DeQueue(T& x){
if(isEmpty()) return false;
else
x=elements[front];
front=(front+1)%maxSize;
return true;
}
template
bool SeqQueue::getFront(T& x){
if(isEmpty()) return false;
else
x=elements[front];
return true;
}
template
ostream& operator<<(ostream& ostr,SeqQueue& Q){
ostr<<"front="<<Q.front<<" "<<"rear="<<Q.rear<<endl;
for(int i=Q.front;i!=Q.rear;i=(i+1)%Q.maxSize)
ostr<<i<<": "<<Q.elements[i]<<endl;
return ostr;
}
########
上面是循环队列，下面是双端队列：

include"SeqQueue.h"

include

using namespace std;
template
class SeqDeque:public SeqQueue{
private:
int front,rear;
int maxSize;
T *elements;
public:
SeqDeque(int sz){ //构造函数
SeqQueue::SeqQueue(sz);
}
~SeqDeque(){ //析构函数
delete[]elements;
}
bool getHead(T& x){ //取队头
return SeqQueue::getFront(x);
}
bool getTail(T& x); //取队尾
bool EnQueueHead(const T& x); //从队头进队
bool EnQueueTail(const T& x){ //从队尾进队
return SeqQueue::EnQueue(x);
}
bool DeQueueHead(T& x){ //从队头出队
return SeqQueue::DeQueue(x);
}
bool DeQueueTail(T& x); //从队尾出队
bool isEmpty(){ //判断队空
return (front==rear)?true:false;
}
bool isFull(){ //判断队满
return SeqQueue::isFull();
}
void makeEmpty(){ //把队置空
front=rear=0;
}
int getSize(){ //求队列元素个数
return (rear-front+maxSize)%maxSize;
}
friend ostream& operator<<(ostream& ostr,SeqDeque& D); //输出运算符重载
};
template
bool SeqDeque::getTail(T& x){
if(isEmpty()) return false;
else{
x=elements[(rear-1+maxSize)%maxSize];
return true;
}
}
template
bool SeqDeque::EnQueueHead(const T& x){
if(isFull()) return false;
else{
front=(front-1+maxSize)%maxSize;
elements[front]=x;
return true;
}
}
template
bool SeqDeque::DeQueueTail(T& x){
if(isEmpty()) return false;
else{
rear=(rear-1+maxSize)%maxSize;
x=elements[rear];
return true;
}
}
template
ostream& operator<<(ostream& ostr,SeqDeque& D){
ostr<<"front="<<D.front<<" "<<"rear="<<D.rear<<endl;
for(int i=D.front;i!=D.rear;i=(i+1)%D.maxSize)
ostr<<i+1<<": "<<D.elements[i]<<endl;
return ostr;
}
#######
下面是主函数：

include"SeqDeque.h"

include

using namespace std;
int main (){
int a,n=5;
SeqDeque D(10);
cout<<"please enter the date into Queue"< while(n--){
cin>>a;
D.EnQueueTail(a);
}
cout<<D<<endl;
system("pause");
return 0;
}

帮你顶顶。。。。。。。。。。。。

模版的定义是
template
class A
{
}
你写的少了T

#include <iostream>
#include <assert.h>

using namespace std;
template <typename T>
class SeqQueue
{
private:
    T *elements; //存放队列元素的数组
    int rear, front; //队尾指针和对头指针
    int maxSize; //队列可容纳的最大元素个数
public:
    SeqQueue(int sz); //构造函数
    ~ SeqQueue()
    {
        delete[]elements;   //析构函数
    }
    bool EnQueue(const T &x); //进队函数
    bool DeQueue(T &x); //出队函数
    bool getFront(T &x); //取队头元素
    void makeEmpty()
    {
        front = rear = 0;   //把队置空
    }
    bool isEmpty()
    {
        return (front == rear) ? true : false;   //判断队空
    }
    bool isFull()
    {
        return ((rear + 1) % maxSize == front) ? true : false;   //判断队满
    }
    int getSize()
    {
        return (rear - front + maxSize) % maxSize;   //求队中元素个数
    }
    friend ostream &operator<<(ostream &ostr, SeqQueue &Q); //输出运算符重载
};

template <typename T>
SeqQueue<T>::SeqQueue(int sz): rear(0), front(0), maxSize(sz)
{
    elements = new T[maxSize];
    assert(elements != NULL); //断言机制：如果不满足括号内条件将终止程序的执行
}

template <typename T>
bool SeqQueue<T>::EnQueue(const T &x)
{
    if (isFull())
    {
        return false;
    }
    else
    {
        elements[rear] = x;
    }
    rear = (rear + 1) % maxSize; //加一再取余是为了rear指向队列最后一个元素（下标maxSize-1），再进一下标就到了0
    return true;
}

template <typename T>
bool SeqQueue<T>::DeQueue(T &x)
{
    if (isEmpty())
    {
        return false;
    }
    else
    {
        x = elements[front];
    }
    front = (front + 1) % maxSize;
    return true;
}

template <typename T>
bool SeqQueue<T>::getFront(T &x)
{
    if (isEmpty())
    {
        return false;
    }
    else
    {
        x = elements[front];
    }
    return true;
}

template <typename T>
ostream &operator<<(ostream &ostr, SeqQueue<T> &Q)
{
    ostr << "front=" << Q.front << " " << "rear=" << Q.rear << endl;
                                        for (int i = Q.front; i != Q.rear; i = (i + 1) % Q.maxSize)
    {
        ostr << i << ": " << Q.elements[i] << endl;
    }
                       return ostr;
}

int main(int argc, char **argv)
{
    SeqQueue<int> s(10);

    int num;
    for (int i = 0; i < 10; ++i)
    {
        std::cin >> num;
    }

    return 0;
}

对比下代码吧, 复制的你上面的改了下