C++，C++/CX に挑戦！

#include <iostream>
using namespace std;

// 抽象クラステンプレート Queue<>
template <class Type> class Queue {
public:
    class Overflow { }; // Overflow例外
    class Empty { };    // Empty例外

    // 純粋仮想デストラクタ
    virtual ~Queue() = 0;

    // 純粋仮想関数 push
    virtual void enqueue(const Type&) = 0;

    // 純粋仮想関数 pop
    virtual Type dequeue() = 0;
};

template <class Type>
Queue<Type>::~Queue() { }

// ------------------------

// 線形リスト仕様キュー ListQueue<>
template <class Type> class ListQueue
    : public Queue<Type> {

    // ノード Node<Type>
    template <class Type> class Node {
        friend class ListQueue<Type> ;    // 「 ; 」追加 ←訂正しました(2/7 00:30)
        Type* data;
        Node* next;
    public:
        Node(Type* d, Node* n)
            : data(d), next(n) { }
    };

    Node<Type>* top;
    Node<Type>* last;

public:
    // コンストラクタ
    ListQueue() {
        top = NULL;
    }

    // デストラクタ
    ~ListQueue() {
        while (top != NULL) {
            if (top->next != NULL) {
                Node<Type>* temp = top->next;
                delete top->data;
                delete top;
                top = temp;
            }
            else {
                delete top->data;
                delete top;
                top = NULL;
            }
        }
    }

    // enqueue
    void enqueue(const Type& x) {
        if (top == NULL)
            top = last = new Node<Type>(new Type(x), NULL);
        else {
            Node<Type>* temp = last;
            try {
                last = new Node<Type>(new Type(x), NULL);
            }
            catch (const std::bad_alloc&) {
                throw Queue<Type>::Overflow();
            }
            temp->next = last;
        }
    }

    // dequeue
    Type dequeue() {
        if (top == NULL) {
            throw Queue<Type>::Empty();
        }
        else if (top->next == NULL) {
            Type temp = *(top->data);
            delete top->data;
            delete top;
            top = NULL;
            return temp;
        }
        else {
            Node<Type>* temp = top->next;
            Type tmp = *(top->data);
            delete top->data;
            delete top;
            top = temp;
            return tmp;
        }
    }
};

// ------------------------

// クラステンプレートの利用プログラム
void enqueue_it(ListQueue<int>& q, int x) {
    try {
        q.enqueue(x);
    }
    catch (const bad_alloc&) {
        cout << "  bad_alloc!!\n";
    }
}

void dequeue_it(ListQueue<int>& x) {
    try {
        int n = x.dequeue();
        cout << ' ' << n << '\n';
    }
    catch (const Queue<int>::Empty&) {
        cout << "  空!!\n";
    }
}

int main() {
    ListQueue<int>* q = new ListQueue<int>();

    while (1) {
        int f; int n;
        cout << "◆ 1.enqueue  2.dequeue  "
            "0.終了 : ";
        cin >> f;

        if (f == 1) {
            try {
                cout << "  整数 : "; cin >> n;
                q->enqueue(n);
            }
            catch (const bad_alloc&) {
                cout << "  bad_alloc!!\n";
            }
        }
        else if (f == 2){
            try {
                cout << "  " << q->dequeue() << '\n';
            }
            catch (const Queue<int>::Empty&) {
                cout << "  空!!\n";
            }
        }
        else {
            delete q; break;
        }
    }
}