[HaBo]

 Anfang          Ende
   |               |
   v               v
  +--+--+--+--+--+---+
  |L |E |E |R |  |   |
  +--+--+--+--+--+---+
Wir können in einem Array Daten ablegen. Wenn wir einen Zähler
haben, können wir z.B mitzählen wie oft etwas eingefügt bzw. wieder entnommen 
wurde und gleichzeitig würde dieser auch auf die Position im Array zeigen, in dem 
das aktuell oberste Element zu finden ist. Also bei jedem Push den Zahler um 1 
erhöhen und bei jedem Pop um 1 erniedrigen. Beim "Top" machen wir nichts mit dem 
Zähler und beim "isEmpty" müssen wir nachschauen, ob der Zähler >0 ist (oder einer 
bestimmten Zahl ;) )

Bsp:
Programmstart:
setzte zaehler=-1;

push(6) -> zaehler=zaehler+1 (also Zaehler=0);
array[zaehler]=6;

  +--+--+--+--+--+---+
  |6 |  |  |  |  |   |
  +--+--+--+--+--+---+
   ^
   | Zähler


Push(8) -> Zaehler=Zaehler+1 (also = 1);
array[zaehler]=8
Push(9)-> Zaehler=Zaehler+1 (also = 2)
array[zaehler]=9
  +--+--+--+--+--+---+
  |6 |8 |9 |  |  |   |
  +--+--+--+--+--+---+
         ^

pop(); ->Zaehler=Zaehler-1 (also wieder 1);
  +--+--+--+--+--+---+
  |6 |8 |9 |  |  |   |
  +--+--+--+--+--+---+
      ^
top() -> rückgabe=array[zaehler] (also array[1]=rückgabe =  8)


Allerdings - hier müsstet ihr noch unbedingt eine Übrprüfung  einbauen, um micht mehr 
Elemente einfügen zu können, als Plätze im Array vorhanden sind.
z.B per isFull() abfragen können oder in der Push() Funktion eine Überprüfung 
durchführen (if (Zaehler<Array_size) zaehler=zaehler+1;

#include <iostream>

using namespace std;

template <typename T>
class Stack
{
    public:
        Stack();
        Stack(int size);
        ~Stack();

        void push(T element);
        T    top();
        T    pop();
        bool isFull() const;
        bool isEmpty() const;

    private:
        T   *stack;
        int  stackSize;
        int  elementOnTop;
};

template <typename T>
Stack<T>::Stack()
{
    Stack(10);
}

template <typename T>
Stack<T>::Stack(int size)
{
    stackSize = size;
    elementOnTop = -1;

    stack = new T[stackSize];
    if (stack == 0)
    {
        throw "Stack could not be created";
    }
}

template <typename T>
Stack<T>::~Stack()
{
    delete[] stack;
}

template <typename T>
void Stack<T>::push(T element)
{
    if (isFull())
    {
        throw "Stack is full";
    }

    elementOnTop++;
    stack[elementOnTop] = element;
}

template <typename T>
T Stack<T>::top()
{
    if (elementOnTop != -1)
    {
        return stack[elementOnTop];
    }
    else
    {
        throw "No element on stack";
    }
}

template <typename T>
T Stack<T>::pop()
{
    if (elementOnTop != -1)
    {
        elementOnTop--;
        return stack[elementOnTop+1];
    }
    else
    {
        throw "No element on stack";
    }
}

template <typename T>
bool Stack<T>::isFull() const
{
    if (elementOnTop + 1 == stackSize)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template <typename T>
bool Stack<T>::isEmpty() const
{
    if (elementOnTop == -1)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int main()
{
    try
    {
        Stack<int> stack(10);

        // stack füllen
        for (int i = 0; !stack.isFull(); i++)
        {
            stack.push(i);
        }

        // stack leeren
        while (!stack.isEmpty())
        {
            cout << stack.pop() << endl;
        }
    }
    catch (const char *error)
    {
        cerr << "Error: " << error << endl;
        return 1;
    }
}