очередь на основе массива

[blackbanny]

когда создаю пустую очередь размерностью 2 в main() вот так BoundQueue <int> a(2);
выводится ошибка:

main.cpp(13) : error C2259: 'BoundQueue<T>' : cannot instantiate abstract class

пишу в Visual Studio 2008

подскажите в чем дело...

вот код классов:
Queue.h

#include <iostream>
using namespace std;
#pragma once
template <class T>
class Queue
{
public:
        //Виртуальный деструктор для переопределения в реализациях
        virtual ~Queue() {}
 
        //Операции с абстрактной очередью:
 
        //Добавление элемента в очередь. Может возникнуть ситуация 
        //QueueOverflow, если в очереди нет места для записи нового элемента.
        virtual void enqueue(const T & e) = 0;
 
        //Удаление элемента из головы очереди. Если ни одного элемента
        //в очереди нет, может возникнуть ситуация QueueUnderflow
        virtual void dequeue() = 0;
 
        //Проверка того, что очередь пуста(не имеет ни одного элемента)
        virtual bool empty() const = 0;
 
        //Четыре функции доступа для чтения/записи 
        //элемента в голове и хвосте очереди
        virtual T & head() = 0;
        virtual const T & head() const = 0;
        virtual T & tail() = 0;
        virtual const T & tail() const = 0;
};

BoundQueue.h

#include "Queue.h"
#include <iostream>
#pragma once
using namespace std;
template <class T> 
class BoundQueue: public Queue<T> 
{
        T *array; //массив элементов очереди
        int MaxSize; //количество элементов в массиве
        int pHead; //индекс первого элемента
        int pTail; //индекс последнего элемента
        int nCount; //количество элементов очереди
 
public:
 
        //Конструктор ограниченной очереди BoundQueue
        BoundQueue(int size);
 
        //Конструктор копирования BoundQueue
        BoundQueue(const BoundQueue<T> & src);
 
        //Деструктор освобождает память, занятую элементами очереди.
        virtual ~BoundQueue() {count = 0; delete[] array;}
 
        //Реализация абстрактных операций над очередью:
 
        //Включение нового элемента в конец очереди
        void enqueue(const T & item);
        //Удаление элемента из головы очереди
        void dequeue();
        //Проверка очереди на пустоту
        bool empty() {return nCount;}
        //Доступ к головному элементу очереди
        T & head();
        const T & head() const;
        //Доступ к хвостовому элементу очереди
        T & tail();
        const T & tail() const;
};
 
//Конструктор нового пустого стека
template <class T> BoundQueue<T>::BoundQueue(int size)
{
        try
        {
                array = new T[MaxSize = size];
        }
        catch(...)
        {
                throw WrongQueueSize("Incorrect size!");
        }
        count = 0;
}
 
//Конструктор копирования 
template <class T> BoundQueue<T>::BoundQueue(const BoundQueue<T> &src)
{
        //Прежде всего выделяется новая память под элементы нового массива
        try
        {
                array = new T[MaxSize = src.MaxSize];
        }
        catch(...) 
        {
        throw WrongStackSize("Incorrect size!");
        }
        //Теперь производится копирование элементов 
        count = src.count;
        for(int i = 0; i < count; i++) array[i] = src.array[i];
}
 
template <class T> void BoundQueue<T>::enqueue(const T &item)
{
        //Проверка, есть ли в массиве место для нового элемента 
        if(nCount == MaxSize) throw QueueOverflow();
        //Помещение элемента в массив
        if(++pTail == MaxSize) pTail = 0;
        array[pTail] = item;
        nCount++;
}
 
template <class T> void BoundQueue<T>::dequeue()
{
        //Проверка, есть ли в очереди хоть один элемент
        if(nCount == 0) throw QueueUnderflow();
        if(++pHead == MaxSize) pHead = 0;
        //Уменьшение счетчика числа элементов
        nCount--;
}
 
template <class T> T & BoundQueue<T>::head()
{
        //Проверка, есть ли в очереди хоть один элемент
        if(nCount == 0) throw QueueUnderflow();
        //Результат - ссылка на головной элемент
        return array[pHead];
}
 
template <class T> const T & BoundQueue<T>::head() const
{
        //Проверка, есть ли в очереди хоть один элемент
        if(nCount == 0) throw QueueUnderflow();
        //Результат - ссылка на головной элемент
        return array[pHead];
}
 
template <class T> T & BoundQueue<T>::tail()
{
        //Проверка, есть ли в очереди хоть один элемент
        if(nCount == 0) throw QueueUnderflow();
        //Результат - ссылка на хвостовой элемент
        return array[pTail];
}
 
template <class T> const T & BoundQueue<T>::tail() const
{
        //Проверка, есть ли в очереди хоть один элемент
        if(nCount == 0) throw QueueUnderflow();
        //Результат - ссылка на хвостовой элемент
        return array[pTail];
}

[blackbanny]

нашел ошибку надо было не virtual bool empty() const = 0;
а virtual bool empty() = 0;