lab 4 try2

#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;
    Node<T>* pNEtop;
public:

    Stack()
    {
        pTop = nullptr;
        pNEtop = nullptr;
    }

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

    void Push(T data)///////////////////////////////////////////////////////////////
    {
        Node<T>* p;
        p = new Node<T>;
        p->data = data;//****************
        p->next = pTop;
        pTop = p;
    }
    Stack(/*const*/ Stack& SL)
    {
        Node<T>* p;
        Node<T>* p2;
        Node<T>* p3;


        pTop = nullptr;
        p3 = nullptr;

        p = SL.pTop;
        while (p != nullptr)
        {
            /*p2 = new Node<T>;
            p2->data = p->data;//********
            p2->next = nullptr;
            if (pTop == nullptr)
            {
                pTop = p2;
                p3 = p2;
            }
            else
            {
                p3->next = p2;
                p3 = p3->next;
            }
            p = p->next;*/
            p2 = new Node<T>;
            p2->data = p->data;
            p2->next = nullptr;
            this->Push(p2->data);
            p = p->next;
        }
    }


    /*void Push(T data)///////////////////////////////////////////////////////////////
    {
        Node<T>* p;
            p = new Node<T>;
        p->data = data;//****************
        p->next = pTop;
        pTop = p;
    }*/


    void Empty()
    {
        Node<T>* p;
        Node<T>* p2;

        p = pTop;

        while (p != nullptr)
        {
            p2 = 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 = nullptr;
        p3 = nullptr;

        p = LS.pTop; // указатель p двигается по списку SL.pTop->...


        while (p != nullptr)
        {

            p2 = new Node<T>;
            p2->data = p->data;
            p2->next = nullptr;
            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!()
    {
        Node<T>* p=this->pTop;
        if (pTop == nullptr) {
            return;
        }
        T max=pTop->data;
        while (pTop != nullptr)
        {
            pTop = pTop->next;
            if ((pTop!=nullptr)&&(pTop->data>max))
            {
                max = pTop->data;
            }
        }
        this->pTop=p;
        cout << "Max element is: " << max << endl;
    }
};