stack.cpp

#include <iostream>
#include <cstdio>


// šablona pro třídu, bude funguvat s jakýmkoli typem (int, double), strukturou, třídou;
template<class T>
class zasobnik {
public:
    // konstruktor, vytvoří prázdný zásobník
    zasobnik() : front(nullptr),count(0) {};
    // konstruktor, vytovří zásobník s 1 prvkem
    zasobnik(const T & in) : front(new elemType(in)),count(1) {};
    // vrací true pokud je zásobník prázdný
    bool empty() const {
        return (front == nullptr) ? true : false;
    };
    // vrací počet prvnků v zásobníku
    size_t size() const {
        return count;
    };
    // vrací referenci (ukazatel) na první prvek zásobníku
    T & top() {
        if (front == nullptr)
            throw "Empty!";
        return *front;
    };
    void push(const T & in) {
        if (front == nullptr)
            front = new elemType(in);
        else {
            elemType * tmp = new elemType(in);
            tmp->next = front;
            front = tmp;
        }
        ++count;
    };
    T pop() {
        if (front == nullptr)
            throw "Empty!";
        T tmp = front->data;
        elemType*tmpp = front->next;
        delete front;
        front = tmpp;
        --count;
        return tmp;
    };

    typedef T value_type;
private:
    struct elemType {
        T data;
        elemType * next;
        elemType() : next(nullptr) {};
        elemType(const T & in) : data(in), next(nullptr) {};
        elemType(const T & in,const T * n) : data(in), next(n) {};
    };
    elemType * front;
    size_t count;

};

// ------------------------------------------------------------------
// neobjektová implementace zasobníku

// šablona pro jednotlive elelmenty zásobníku (vagónky), T je typ nákladu, může btý jakýkoli
template<class T>
struct elemType {
    T data;             // náklad
    elemType * next;    // další vagon
    elemType() : next(nullptr) {};      // vytvoří prázdný vagón
    elemType(const T & in) : data(in), next(nullptr) {};    // vytvoří vagon s nákladem, bez zádného který by ho následoval
    elemType(const T & in,elemType * n) : data(in), next(n) {};  // vytvoří vago ns nákladem a určí jaký vagon bude následovat
};

// šablona pro přidání vagonku do vlaku, T je typ nákladu, může btý jakýkoli
template<class T>
// ano je tam ukazatel na ukazatel, ale takhle se to dělá :D
void push(elemType<T> ** front, const T & in) {
    // vlak je prázdný, vyrobíme vagon a čau
    if (*front == nullptr)
        *front = new elemType<T>(in);
    // něco už ve valku připojíme na začátek
    else {
        // vytvoří vagon, s náklem (in) a bude ho následovat ten co byl doteď první
        elemType<T> * tmp = new elemType<T>(in,*front);
        // začátek valku bude na našem novém vagonu
        *front = tmp;
    }
}

// vyjme první vagon
template<class T>
T pop(elemType<T> ** front) {
    // vlak je prázdný, nemám co vracet, hodím chybu
    if (*front == nullptr)
        throw "Empty!";
    // toto si uchovám, to je můj náklad který chci
    T tmp = (*front)->data;
    // zapamatuju si, který vagon ude nově první
    elemType<T> * tmpp = (*front)->next;
    // odstraním vyložený vagon
    delete *front;
    // určím nový první
    *front = tmpp;
    // vrátím náklad
    return tmp;
}

template<class T>
bool empty(const elemType<T> * front) {
    return (front == nullptr) ? true : false;
}



int main()
{
    // prázdný zásobník (vlak)

    elemType<int> * s = nullptr;
    for(int i = 0; i <= 5; i++){
        push(&s,i);
    }
    printf("Vypisuju:\n");
    while (!empty(s))
        printf("%d\n",pop(&s));

        return 0;
}