#include <iostream>

template <typename T>
class Stack1 {
private:
    T * stackPtr;
    const int size;
    int top;
public:
    Stack1(int n);
    Stack1(const Stack1<T>&);
    ~Stack1();

    inline void push(const T &);
    inline T pop();
    inline const T &peek(int) const;
    inline void stackout();
    inline void pol_out();

    inline int get_size() const;
    inline int get_top() const;
    inline T *get_Ptr() const;
};

template <typename T>
Stack1<T>::Stack1(int SizeSt) : size(SizeSt) {
    stackPtr = new T[size];
    top = 0;
}

template <typename T>
Stack1<T>::Stack1(const Stack1<T>& Stack2) :size(Stack2.get_size()) {
    stackPtr = new T[size];
    top = Stack2.get_top();
    for (int ix = 0; ix < top; ix++)
        stackPtr[ix] = Stack2.getPtr()[ix];
}

template <typename T>
Stack1<T>::~Stack1() {
    delete[] stackPtr;
}

template <typename T>
inline void Stack1<T>::push(const T& value) {
    if (top < size) stackPtr[top++] = value;
}

template <typename T>
inline T Stack1<T>::pop() {
    if (top > 0) stackPtr[--top];
    return NULL;
}

template <typename T>
inline const T &Stack1<T>::peek(int num) const {
    if (num <= top)  return stackPtr[top - num];
}

template <typename T>
inline void Stack1<T>::stackout() {
    for (int ix = 0; ix < top - 1; ix++)
        cout << stackPtr[ix] << ", ";
    cout << stackPtr[top - 1] << endl;
}

template <typename T>
inline void Stack1<T>::pol_out() {
    for (int ix = 0; ix <= top - 1; ix++)
        cout << stackPtr[ix] << "  ";
    cout << endl;
}

template <typename T>
inline int Stack1<T>::get_size() const {
    return size;
}

template <typename T>
inline int Stack1<T>::get_top() const {
    return top;
}

template <typename T>
inline T*Stack1<T>::get_Ptr() const {
    terurn stackPtr;
}