lab2

#include <iostream>
#include <deque>

using namespace std;


////////////////////////////////////////////////////////////////


template< class T  >
class stack {

    private:
        deque<T> container;

//--------------------------------------------------------------

    public:
        // Дефолтный констурктор
        stack() { /* ... */ }

//--------------------------------------------------------------

        // Копирующий конструктор
        stack(const stack& value) : container(value.container) { /* ... */ }

//--------------------------------------------------------------

        // Возвращает стэк с присвоенными данными
        stack<T>& operator= (const stack& value) {
            container = value.container;

            return (*this);
        }

//--------------------------------------------------------------

        // Возвращает стэк с новым элементом
        stack<T> operator+ (const T& value) const {
            stack<T> tempStack(*this);
            tempStack.container.push_back(value);



            return tempStack;
        }

//--------------------------------------------------------------

        // Возвращает стэк с умноженой верхушкой
        stack<T> operator* (const T& value) const {
            stack<T> tempStack(*this);
            tempStack.container.back() *= value;



            return tempStack;
        }

//--------------------------------------------------------------

        // Возвращает стэк без последнего элемента
        stack<T> operator- ( ) const {
            stack<T> tempStack(*this);
            tempStack.container.pop_back();



            return tempStack;
        }

//--------------------------------------------------------------

        // Сравнивает контейнеры
        bool operator== (const stack<T>& value) const {

            return value.container == container;
        }

//--------------------------------------------------------------

        // Сравнивает контейнеры
        bool operator!= (const stack<T>& value) {

            return value.container != container;
        }

//--------------------------------------------------------------

        // Добавляет в контейнер элементы аргумента
        void operator+= (const stack<T>& value) {
            for (auto iter : value.container) {
                container.push_back(iter);
            }
        }

//--------------------------------------------------------------

        // Добавляет в контейнер аргумент
        void operator+= (const T& value)
            { container.push_back(value); }

//--------------------------------------------------------------

        // Добавление нового элемента через cin
        friend istream& operator>>(istream& stream, stack<T>& con) {
            T value; stream >> value;
            con.container.push_back(value);



            return stream;
        }

//--------------------------------------------------------------

        // Вывод последнего элемента через cout
        friend ostream& operator<<(ostream& stream, stack<T> container)
            { stream << container.container.back(); return stream; }


};


////////////////////////////////////////////////////////////////

int main() {
    cout.setf(ios::boolalpha);

    stack<int> testStack1;
    cout << "Input first element testStack1<int>: "; cin >> testStack1;
    cout << "First element testStack1: " << testStack1 << endl;
    testStack1 += 2;
    testStack1 += 4;
    testStack1 += 8;
    testStack1 += 16;

    stack<int> testStack2(testStack1 + 32);
    cout << (-testStack1) << endl << (testStack2 * 10) << endl;
    cout << "testStack1 == testStack2: " << (testStack1 == testStack2) << endl;
    cout << "testStack1 != testStack2: " << (testStack1 != testStack2) << endl;

    testStack1 += testStack2;
    cout << "testStack1 += testStack2: " << testStack1 << endl;



    return 0;
}