Конструктор копирования для класса стек

struct Item
    {
        int value;
        Item *next;
    };
 
class Int_stack
{
    Item *ptr_stack;
    void push_in_tail(Item*&, const int new_value);
public:
    Int_stack();
    Int_stack(const Int_stack&);
    ~Int_stack();
    
    void push(const int new_value);
    int pop();
};

#include "stack.h"
#define null 0 // у меня почему-то компилятор не определяем не NULL не nullptr, так что будет так.
 
Int_stack::Int_stack():ptr_stack(null){}
 
Int_stack::Int_stack(const Int_stack &parent_stack) : ptr_stack(null)
{
    Item *copy_parent_stack = parent_stack.ptr_stack;
    Item *p_tail_stack = ptr_stack;
    while (copy_parent_stack -> next != null)
    {
        push_in_tail(p_tail_stack, copy_parent_stack -> value);
        copy_parent_stack = copy_parent_stack -> next;
    }
    delete p_tail_stack;
    delete copy_parent_stack;
}
 
Int_stack::~Int_stack()
{
    Item *temp = ptr_stack;
    while (temp != null)
    {
        temp = ptr_stack->next;
        delete ptr_stack;
        ptr_stack = temp;
    }
    delete temp;
}
 
void Int_stack::push(const int new_value)
{
    Item *temp = new Item;
    temp -> value = new_value;
    temp -> next = ptr_stack;
    ptr_stack = temp;
}
 
int Int_stack::pop()
{
    int number = ptr_stack -> value;
    Item *temp = ptr_stack;
    ptr_stack = ptr_stack -> next;
    delete temp;
    return number;
}
 
void Int_stack::push_in_tail(Item* &p_tail, const int new_value)
{
    Item *temp = new Item;
    temp -> value = new_value;
    temp -> next = null;
    p_tail -> next = temp;
    delete temp;
}

#include <iostream>
#include "stack.h"
 
 
int main()
{
    Int_stack *my_stack = new Int_stack();
    for(int i = 0; i < 10; i++)
    {
        my_stack -> push(i + 1);
    }
/*  
// если начинаю создавать второй класс с помощью конструктора копирования виснет все
    Int_stack *my_stack2 = new Int_stack(*my_stack);
 
    std::cout << "Stack 2:" << std::endl << std::endl;
    {
        for(int i = 0; i < 10; i++)
        {
            std::cout << my_stack2 -> pop() << std::endl;
        }   
        std::cout << std::endl;
    }
        delete my_stack2;
*/
    std::cout << "Stack 1:" << std::endl << std::endl;
    {
        for(int i = 0; i < 10; i++)
        {
            std::cout << my_stack -> pop() << std::endl;
        }   
        std::cout << std::endl;
    }
    
    delete my_stack;
    system("pause");
}

void Int_stack::push_in_tail(Item* &p_tail, const int new_value)
{
    Item *temp = new Item;
    temp -> value = new_value;
    temp -> next = null;
    p_tail -> next = temp; // в функцию передавался null, при обращении будет крэш
    delete temp; // зачем удалять только что созданный объект? он должен храниться в стеке, пока его не извлекут.
    // только потом уже удалять
}

void Int_stack::push_in_tail(Item* &p_tail, const int new_value)
{
    Item *temp = new Item;
    temp -> value = new_value;
    temp -> next = null;
    p_tail -> next = temp;
    p_tail = p_tail -> next;
    delete temp;
}

Node *Temp = new Node; // создаем узел
Temp->elem = val // записываем в узел то что нам нужно
if(tail == 0) // делаем проверку, равен ли 0 хвост
{
   tail = Temp; // если да, перезаписываем
}
else // иначе
{
  Temp->next = tail; // смещаем хвост, а не делаем его равным 0 как у вас
  tail = Temp;
}

    Item *temp = new Item; // создаётся объект Item, его адрес присваивается указателю temp
    // ...
    delete temp; // удаляется объект, на который указывал temp,
    // сам указатель "удалится" автоматически при выходе из функции,
    // так как был объявлен внутри неё

void Int_stack::push_in_tail(Item* &p_tail, const int new_value)
{
    Item *temp = new Item;
    temp -> value = new_value;
    temp -> next = null;
    if(p_tail == null) p_tail = temp;
    else
    {
        p_tail -> next = temp;
        p_tail = p_tail -> next;
    }
}

Int_stack::Int_stack(const Int_stack &parent_stack) : ptr_stack(null)
{
    Item *copy_parent_stack = parent_stack.ptr_stack;
 
        // ниже две строчки, благодаря которым перестала терять указатель на начало списка
    push_in_tail(ptr_stack, copy_parent_stack->value); 
    copy_parent_stack = copy_parent_stack->next;
    
    Item *p_tail_stack = ptr_stack;
    
    while (copy_parent_stack != null)
    {
        push_in_tail(p_tail_stack, copy_parent_stack->value);
        copy_parent_stack = copy_parent_stack->next;
    }
    delete copy_parent_stack;
}

void Int_stack::push_in_tail(Item* &p_tail, const int new_value)
{
    Item *temp = new Item;
    temp -> value = new_value;
    temp -> next = null;
    if(p_tail == null)
        p_tail = temp;
    else
    {
        p_tail -> next = temp;
        p_tail = p_tail -> next;
    }
}