// Lösung zur Ausnahmebehandlung

// Zuerst Dateien einbinden
#include <iostream>

using std::cout;
using std::endl;

// Definition der Template-Klasse Stack
template <typename T>
class Stack
{
     short   stackPtr;      // Stackindex (Stackpointer)
     short   size;          // Stackgrösse
     T       *pData;        // Zeiger auf Stack
  public:
     Stack(const short s);
     ~Stack();
     void   Push(const T&);
     T&     Pop();
};
// Definition der Memberfunktionen
// Konstruktor
template<typename T>
Stack<T>::Stack(const short s)
{
    // Falls mehr als 100 Elemente auf Stack, Ausnahme auslösen
    if (s > 100)
        throw "Max. Stackgrösse überschritten";
    // Feld für Stackdaten anfordern
    // Wirft eventl. bad_alloc Ausnahme
    pData = new T[s];
    // Stackparameter merken
    size = s;
    stackPtr = 0;
}
// Destruktor
template<typename T>
Stack<T>::~Stack()
{
    delete [] pData;
}
// Legt Datum auf dem Stack ab
template <typename T>
void Stack<T>::Push(const T& val)
{
    // Falls Stack schon voll ist
    if (stackPtr==size)
        throw "Stack belegt";
    // Datum ablegen
    pData[stackPtr++] = val;
}
// Liest Datum vom Stack aus
template <typename T>
T& Stack<T>::Pop()
{
    // Falls Stack leer
    if (stackPtr==0)
        throw "Stack leer";
    // Datum holen
    return pData[--stackPtr];
}

// main() Funktion
int main()
{
    // Zeiger auf short-Stack
    Stack<short> *pStack;
    // Versuche short-Stack mit 5 Elementen anzulegen
    try
    {
        pStack = new Stack<short>(5);
    }
    // Falls Fehler beim Anlegen des Stack aufgetreten
    // Meldung ausgeben und Programm beenden
    catch(const char *const pT)
    {
        cout << "\nFEHLER: " << pT << endl;
        exit(1);
    }
    catch(std::bad_alloc&)
    {
        cout << "Nicht genügend Speicher!" << endl;
        exit(2);
    }
    // Stack nun komplett füllen
    // Falls Stack voll ist wird Ausnahme ausgelöst
    cout << "Fülle Stack:\n";
    try
    {
        int index = 10;
        for (;;)
            pStack->Push(index++);
    }
    catch(const char *const pT)
    {
        cout << "FEHLER:" << pT << endl;
    }
    // Stack jetzt wieder leeren
    // Falls Stack leer wird Ausnahme ausgelöst
    cout << "Leere Stack:\n";
    try
    {
        for (;;)
            cout << pStack->Pop() << ",";
    }
    catch(const char *const pszT)
    {
        cout << "\nFEHLER:" << pszT << endl;
    }
    // Stack löschen
    delete pStack;

    // Versuche z grossen Stack anzulegen
    cout << "Lege riesigen Stack an:\n";
    try
    {
        Stack<short> hugeStack(1000);
    }
    catch(const char *const pT)
    {
        cout << "\nFEHLER:" << pT << endl;
        exit(1);
    }
    catch(std::bad_alloc&)
    {
        cout << "Nicht genügend Speicher!" << endl;
        exit(2);
    }
}