Наличие как Конструктора Копирования, так и Деструктора приводит к segfault, но наличие только одного или другого не

Это что-то очень странное, с чем я столкнулся, которого я никогда раньше не видел.
Я пишу стек ADT для компьютерного проекта.

Это моя ситуация:

Когда я пытаюсь протестировать конструктор копирования, используя функцию (значение call-by), я получаю segfault при запуске моей программы.

Поэтому я посмотрел на мой код и искал обычные причины ошибок (двойное удаление, логическая ошибка указателя и т. Д.) И ничего не смог найти.

Поэтому я попытался закомментировать тело копии (это только тело, а не прототип функции, а только тело), ​​но я все еще получил ошибку сегмента.

Затем я попытался полностью закомментировать конструктор копирования (protype, function и все), а затем никакого segfault (но, конечно, у меня остался конструктор по умолчанию, что плохо с указателями)

Так что это действительно смутило меня, почему просто иметь конструктор копирования вообще, даже если он ничего не делал, вызывал segfault?

Я попробовал то же самое с деструктором и обнаружил, что после того, как я полностью закомментировал его (это прототип и все), я снова обнаружил, что код работает без segfaults (но, конечно, это означает, что без деструктора, что вызывает утечки памяти!)

  //test.cpp - test program to test the copy constructor
#include "stack.hpp"
void test(STACK <int> x){
}

int main(void){
STACK <int> a;
a.push(1); a.push(2);
test(a);
}

//stack.hpp - ADT developed for project

//Stack.hpp -> developed for project 3
#include <cassert>
#include <new>
#include <iostream>

#ifndef STACK_HPP
#define STACK_HPP
const bool debug= false;template<class T>
class NODE{

public:
NODE(){next= 0;};
T data;
NODE *next;
};template <class U>
class STACK{

public:
STACK(){begin= 0;};

bool empty()const{return begin == 0;};
bool full()const;
void push(U);
U pop();
void swap(STACK <U> &);

~STACK();
STACK(const STACK <U> &);
STACK <U> & operator=(const STACK <U> &);

private:
NODE <U> *begin;

};

template <class U>
bool STACK<U>::full()const{
NODE <U> *test= new(std::nothrow) NODE <U>;

if(test== 0){
return true;
}

else{
delete test;
return false;
}
}

//Requires not full
template <class U>
void STACK<U>::push(U x){
assert(!full());

if(empty()== true){
begin= new NODE <U>;
}

else{
NODE <U> *tmp= new NODE <U>;
tmp->next= begin;
begin= tmp;
}

begin->data= x;

}

//Requires not empty
template <class U>
U STACK<U>::pop(){
assert(!empty());
U result;

if(begin->next == 0){
result= begin->data;
delete begin;
begin= 0;
}

else{
NODE <U> *tmp= begin->next;
result= begin->data;
delete begin;
begin= tmp;
}

return result;
}

template <class U>
STACK<U>::~STACK(){
if(debug)std::cout << "destroy";

while(!empty())
pop();

}

template <class U>
STACK<U>::STACK(const STACK <U> & orig){
if(debug)std::cout << "copy";

if(!orig.empty()){
NODE <U> *cur= orig.begin;
STACK temp;

while(cur!= 0){
temp.push(cur->data);

cur= cur->next;
}

cur= temp.begin;

while(cur!= 0){
push(cur->data);
cur= cur->next;
}

}
}

template <class U>
void STACK<U>::swap(STACK <U> & other){
NODE <U> *tmp= begin;

begin= other.begin;

other.begin= tmp;
}

template <class U>
STACK<U>& STACK<U>::operator=(const STACK& rhs){
STACK tmp(rhs);
swap(tmp);
return *this;
}

#endif