Оцените Stack

#include "stdafx.h"
#include <iostream>
using namespace std;
 
class Stack
{
private:
    int push_index = 0;
    int n = 5;
    int *arr;
public:
    bool is_empty();
    void add();
    void exclude();
    void push(int value);
    int pop();
    int show();
};
 
bool Stack::is_empty()
{
    return push_index == 0;
}
 
void Stack::add()
{
    int *new_arr = new int[n * 2];
    for (int i = 0; i < n; i++)
    {
        new_arr[i] = arr[i];
    }
    delete[] arr;
    arr = new_arr;
    n *= 2;
}
 
void Stack::exclude()
{
    int *new_arr = new int[n / 2];
    for (int i = 0; i < n; i++)
    {
        new_arr[i] = arr[i];
    }
    delete[] arr;
    arr = new_arr;
    n /= 2;
}
 
void Stack::push(int value)
{
    if (push_index == n)
    {
        add();
    }
    arr[push_index] = value;
    push_index++;
}
 
int Stack::pop()
{
    if (push_index == n * 0.4)
    {
        exclude();
    }
    push_index--;
    return arr[push_index];
}
 
int Stack::show()
{
    return n;
}
 
bool stack_test()
{
    bool test_passed = true;
    Stack st;
    st.push(1);
    st.push(2);
    st.push(3);
    st.push(4);
    st.push(5);
    st.push(6);
    st.push(7);
    test_passed &= st.pop() == 7;
    test_passed &= st.pop() == 6;
    test_passed &= st.pop() == 5;
    test_passed &= st.pop() == 4;
    test_passed &= st.pop() == 3;
    test_passed &= st.pop() == 2;
    test_passed &= st.pop() == 1;
    return test_passed;
}
 
bool emptiness_test()
{
    bool test_passed = true;
    Stack st;
    test_passed &= st.is_empty();
    st.push(5);
    test_passed &= !st.is_empty();
    st.pop();
    test_passed &= st.is_empty();
    return test_passed;
}
 
int main()
{
    if (emptiness_test())
    {
        cout << "test passed" << endl;
    }
    else
    {
        cout << "test failed" << endl;
    }
 
    if (stack_test())
    {
        cout << "test passed" << endl;
    }
    else
    {
        cout << "test failed" << endl;
    }
 
    system("pause");
    return 0;
}

#ifndef _STACK_H_
#define _STACK_H_
//-------------------------------------------------------------------------------------------------
template <typename Type>
class Stack
{
private:
    struct Node
    {
        Type element = {};
        Node* next = nullptr;
    };
    size_t count;
    Node* tail;
public:
    //Member functions
    Stack();
    Stack(const Stack & stk);
    Stack(Stack && stk);
    Stack & operator = (const Stack & stk);
    Stack & operator = (Stack && stk);
    ~Stack();
    
    //Element access
    const Type & top() const;
 
    //Capacity
    bool empty() const;
    size_t size() const;
 
    //Modifiers
    void push(const Type & val);
    void push(Type && val);
    void swap(Stack & stk);
    //emplace Not implemented
    void pop();
};
//-------------------------------------------------------------------------------------------------
template <typename Type>
Stack<Type>::Stack() : count(0), tail(nullptr)
{
    //Body of the constructor class
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
Stack<Type>::Stack(const Stack & stk) : count(stk.count), tail(nullptr)
{
    Node **n_ptr_next = &tail;
    for (const Node* n_ptr = stk.tail; n_ptr != nullptr; n_ptr = n_ptr->next)
    {
        Node* n_ptr_new = new Node(*n_ptr);
        *n_ptr_next = n_ptr_new;
        n_ptr_next = &n_ptr_new->next;
    }
    *n_ptr_next = nullptr;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
Stack<Type>::Stack(Stack && stk) : count(stk.count), tail(stk.tail)
{
    stk.count = 0;
    stk.tail = nullptr;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
Stack<Type> & Stack<Type>::operator = (const Stack & stk)
{
    if (this == &stk)
    {
        return *this;
    }
 
    Stack temp(stk);
    std::swap(tail, temp.tail);
    std::swap(count, temp.count);
    return *this;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
Stack<Type> & Stack<Type>::operator = (Stack && stk)
{
    if (this == &stk)
    {
        return *this;
    }
 
    std::swap(tail, stk.tail);
    std::swap(count, stk.count);
    return *this;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
Stack<Type>::~Stack()
{
    while (tail)
    {
        Node* n_ptr_del = tail;
        tail = tail->next;
        delete n_ptr_del;
    }
    count = 0;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
void Stack<Type>::push(Type && val)
{
    Node* n_ptr_new = new Node;
    n_ptr_new->element = val;
    count++;
    n_ptr_new->next = tail;
    tail = n_ptr_new;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
void Stack<Type>::push(const Type & val)
{
    Node* n_ptr_new = new Node;
    n_ptr_new->element = val;
    count++;
    n_ptr_new->next = tail;
    tail = n_ptr_new;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
void Stack<Type>::pop()
{
    Node* n_ptr_del = tail;
    tail = tail->next;
    count--;
    delete n_ptr_del;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
const Type & Stack<Type>::top() const
{
    if (empty())
    {
        throw std::runtime_error("Stack<Type>::top: empty stack");
    }
    return tail->element;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
size_t Stack<Type>::size() const
{
    return count;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
bool Stack<Type>::empty() const
{
    return tail == nullptr;
}
//-------------------------------------------------------------------------------------------------
template <typename Type>
void Stack<Type>::swap(Stack & stk)
{
    Stack temp(stk);
    stk = std::move(*this);
    *this = std::move(temp);
}
//-------------------------------------------------------------------------------------------------
#endif // STACK_H_