Чем стек программно от очереди отличается?

struct Waiting
{
    Waiting* next;
    int count;
};
 
Waiting* Create()
{
    Waiting* first = new Waiting;
    Waiting* now = first;
 
    while (scanf("%d", &now->count))
    {
        now->next = new Waiting;
        now = now->next;
    }
 
    now->next = NULL;
 
    return first;
}
 
void Print(Waiting *first)
{
    Waiting* now = first;
 
    while (now->next != NULL)
    {
        cout << "now: " << now->count << endl;
        now = now->next;
    }
}

Stack* Create()
{
    Stack* top;
    Stack* now = new Stack;
 
    while (scanf("%d", &now->count))
    {
        now->prev = new Stack;
        now = now->prev;
    }
 
    top = now;
 
    top->prev = NULL;
 
    return top;
}

//g++  5.4.0
 
#include <iostream>
 
 
template<typename T>
class Stack
{
public:
    Stack() : mTop(0) {}
    void push(const T &value) 
    {
        mTop = new StackNode(value, mTop);
    }
    bool pop()
    {
        if (mTop) {
            StackNode *d = mTop;
            mTop = mTop->next;
            delete d;
        }
        return mTop != 0;
    }
    T *top() const
    {
        if (mTop) {
            return &(mTop->value);
        }
        return 0;
        
    }
    ~Stack()
    {
        while (pop()) {
        }
    }
private:
    struct StackNode {
        StackNode (const T &value_, StackNode *next_) : value(value_), next(next_){}
        T value;
        StackNode *next;
    };
    StackNode *mTop;
};
 
 
int main()
{
    Stack<int> stack;
    stack.push(10);
    stack.push(12);
    stack.push(13);
    while (stack.top()) {
        std::cout << *stack.top() << ", ";
        stack.pop();
    }
}

template<typename T>
class Stack
{
public:
    Stack() : mTop(0) {}//В конструкторе инициализируем указатель нулем
    
    void push(const T &value) //Запинать в стек
    {
        //Создаем новый узел, при этом у него next делаем равным mTop,
        //т.е. текущая вершина стека станет следующим 
        //узлом для вновь созданного узла.
        //Ну и новый узел делаем вершиной стека.
        mTop = new StackNode(value, mTop);
    }
    
    bool pop()//Вышвырнуть из стека
    {
        if (mTop) {//Если в стеке есть элементы, то
            StackNode *d = mTop;//сохраняем указатель на вершину в d
            mTop = mTop->next;//следующий узел делаем верхним
            delete d;//удаляем прошлую верхушку
        }
        return mTop != 0;//вернет true, если в стеке имеются еще элементы
    }
    
    T *top() const //Заглянуть в щелку
    {
        if (mTop) {//Если в стеке есть элементы, то
            return &(mTop->value);//возвращаем указатель на значение, сохраненное в верхнем узле
        }
        return 0;//иначе возвращаем 0
        
    }
    
    ~Stack()
    {
        //Харакири для всех узлов
        while (pop()) {//удаляем элементы, пока они есть
        }
    }
private:
    struct StackNode {//узел стека
        StackNode (const T &value_, StackNode *next_) : value(value_), next(next_){}
        T value;//Значение, хранимое в узле
        StackNode *next;//Указатель на следующий узел
    };
    StackNode *mTop;//Указатель на верхний узел стека
};