labb 4

#pragma once
#include <iostream>
#include <conio.h>
using namespace std;
template <class T>
class Node
{
    Node* next;
    T data;
    template <typename U>
    friend class Stack;
};


template <class T>
class Stack
{
private:
    Node<T>* pTop;

public:

    Stack() { pTop = nullptr; }

    Stack(Node<T>* SL)
    {
        if (SL == nullptr)
        {
            pTop = nullptr;
            return;
        }
        this->pTop = SL;
        this->next = nullptr;
    }


    Stack(const Stack& SL)
    {
        Node<T>* p; // дополнительные указатели
        Node<T>* p2;
        Node<T>* p3;


        pTop = nullptr;
        p3 = nullptr;

        p = SL.pTop; // указатель p движется по списку SL.pTop->...
        while (p != nullptr)
        {
            // 1. Сформировать узел p2
            try {
                // попытка выделения памяти
                p2 = new Node<T>;
            }
            catch (bad_alloc e)
            {
                // если память не выделена, то выход
                cout << e.what() << endl;
                return;
            }
            p2->data = p->data;//********
            p2->next = nullptr;

            // 2. pTop = pTop + p2
            if (pTop == nullptr) // создать очередь
            {
                pTop = p2;
                p3 = p2;
            }
            else
            {
                p3->next = p2;
                p3 = p3->next;
            }

            // 3. Перейти на следующий элемент
            p = p->next;
        }
    }


    void Push(T data)
    {
        Node<T>* p;

        //  Сформировать элемент
        try {
            p = new Node<T>; // попытка выделить память
        }
        catch (bad_alloc e)
        {
            // если память не выделилась, то выход
            cout << e.what() << endl;
            return;
        }
        p->data = data;//****************
        p->next = pTop; // p указывает на 1-й элемент

        // 2. Перенаправить pTop на p
        pTop = p;
    }

    // Количество элементов в стеке
    /*int Count()
    {
        if (pTop == nullptr)
            return 0;
        else
        {
            Node<T>* p = pTop;
            int count = 0;

            while (p != nullptr)
            {
                count++;
                p = p->next;
            }
        }
    }*/

    // очищает стек - удаляет все элементы из стека
    void Empty()
    {
        Node<T>* p; // дополнительный указатель
        Node<T>* p2;

        p = pTop;

        while (p != nullptr)
        {
            p2 = p; // сделать копию из p
            p = p->next; // перейти на следующий элемент стека
            delete p2; // удалить память, выделенную для предыдущего элемента
        }
        pTop = nullptr; // поправить вершину стека
    }

    Stack<T>& operator=(const Stack<T>& LS)
    {
        // есть ли элементы в стеке?
        if (pTop != nullptr) Empty();

        Node<T>* p; // дополнительный указатель
        Node<T>* p2;
        Node<T>* p3;

        // Инициализировать pTop
        pTop = nullptr;
        p3 = nullptr;

        p = LS.pTop; // указатель p двигается по списку SL.pTop->...
        while (p != nullptr)
        {
            // 1. Сформировать узел p2
            try {
                // попытка выделить память
                p2 = new Node<T>;
            }
            catch (bad_alloc e)
            {
                // если память не выделена, то выход
                cout << e.what() << endl;
                return *this;
            }
            p2->data = p->data;
            p2->next = nullptr;

            //  pTop = pTop + p2
            if (pTop == nullptr) // создать стек
            {
                pTop = p2;
                p3 = p2;
            }
            else
            {
                p3->next = p2;
                p3 = p3->next;
            }

            //  Перейти на следующий элемент
            p = p->next;
        }
        return *this;
    }


    void Print(const char* objName)
    {
        cout << "Object: " << objName << endl;
        if (pTop == nullptr)
            cout << "stack is empty." << endl;
        else
        {
            Node<T>* p; // дополнительный указатель
            p = pTop;
            while (p != nullptr)
            {
                cout << p->data << "\t";
                p = p->next;
            }
            cout << endl;
        }
    }


    ~Stack()
    {
        Empty();
    }


    T Pop()
    {
        if (pTop == nullptr)
            return 0;

        Node<T>* p2;
        T data;
        data = pTop->data;

        p2 = pTop;
        pTop = pTop->next;

        // Освободить память, выделенную под 1-й элемент
        delete p2;
        return data;
    }


    void operator!()
    {
        if (pTop == nullptr) {
            return;
        }
        T max=pTop->data;
        while (pTop != nullptr)
        {
            pTop = pTop->next;
            if ((pTop!=nullptr)&&(pTop->data>max))
            {
                max = pTop->data;
            }
        }
        cout << "Max element is: " << max << endl;
    }
};





#include <iostream>
#include "Stack.h"

using namespace std;

int main()
{
    Stack <int> ST;
    ST.Print("ST");

    ST.Push(8);
    ST.Push(5);
    ST.Push(10);
    ST.Push(7);
    ST.Print("ST");

    Stack <int> ST2 = ST;
    Stack <int> ST4 = ST;
    ST2.Print("ST2");
    ST4.Print("ST4");
    ST.Empty();
    ST.Print("ST");

    ST = ST2;
    ST.Print("ST = ST2");

    Stack <int> ST3;
    ST3.Push(1);
    ST3.Push(2);
    ST3.Push(3);
    ST3.Print("SL3");

    ST = ST2 = ST3;
    ST.Print("ST");
    ST2.Print("ST2");

    !ST4;

    int d = ST2.Pop();

    cout << "POP = " << d << endl;
    ST2.Print("ST2-1");

    d = ST2.Pop();
    ST2.Print("ST2-2");

    d = ST2.Pop();
    ST2.Print("ST2-3");

    d = ST2.Pop();
    cout << "POP = " << d << endl;
    ST2.Print("ST2----");
    return 0;
}