Реализация своего pop() для стека

#include <iostream>
#include <cstdlib>
 
namespace s21 {
    template <class T>
    class stack {
        public:
            using value_type = T;
            using reference = T&;
            using const_reference = const T&;
            using size_type = std::size_t;
        
        public:
            stack();
            ~stack();
            void push(const_reference value);
            const_reference top();
            void pop();
 
        private:
            T *array_;
            size_t size_;
            size_t capacity_;
    };
}
 
 
 
namespace s21 {
    template <class T> 
    stack<T>::stack() : array_(nullptr), size_(0), capacity_(0) {}
 
    template <class T> 
    stack<T>::~stack() {
        if (size_ != 1) {
            array_ -= size_ - 1;
           // delete [] array_;
        }
    }
 
    template <class T>
    void stack<T>::push(const_reference value) {
        if (size_ == 0) {
            capacity_ = 10;
            array_ = new T[capacity_];
        } else {
            array_++;
        }
        if (size_ == capacity_) {
            capacity_ += 10;
            T *tmp = new T[capacity_];
            std::copy(array_, array_ + 10, tmp);
            delete [] array_;
            array_ = tmp;
        } 
        size_++;
        *array_ = value;
    }
 
    template <class T>
    typename stack<T>::const_reference stack<T>::top() {
        if (size_ == 0) {
            throw(std::out_of_range("Stack is empty"));
        }
        return *array_;
    }
 
    template <class T>
    void stack<T>::pop() {
        T *temp = array_;
        array_--;
        delete temp;
        size_--;
    }
}
 
int main() {
    s21::stack <int> steck_;
    steck_.push(1);
    steck_.push(2);
    steck_.push(3);
    steck_.push(4);
    steck_.pop();
    std::cout << steck_.top();
    return 0;
}