C++ 叮当声错误：未分配要释放的指针

我写了这个链表的实现：

template<typename T>  // implementation: Linked_list 
class Linked_list {  
    private:
        Node<T>* head;
        Node<T>* tail;
        Node<T>* current;
        int size;


        void init() 
        {
            head = tail = current = new Node<T>();
            size = 0;
        }


        Node<T>* search_previous()
        {
            if (current == head) {
                return nullptr;
            }
            Node<T>* previous_node = head;
            while (previous_node->next != current) {
                previous_node = previous_node->next;
            }
            return previous_node;
        }


    public:
        Linked_list() 
        {
            init();
        }


        void clear() 
        {
            while (head != nullptr) {
                current = head;
                head = head->next;
                delete current;

            }
            init();
        }


        ~Linked_list() 
        {
            clear();
            delete head;
        }


        void append(T p_element) 
        {
            tail->next = new Node<T>(p_element);
            tail = tail->next;
            ++size;
        }


        void insert(T p_element)
        {
            current->next = new Node<T>(p_element, current->next);
            if (current == tail) {
                tail = tail->next;
            }
            ++size; 
        }


        T remove() 
        {
            if (current->next == nullptr) {
                throw std::runtime_error("No element to remove");
            }
            T removed_element = current->next->element;
            Node<T>* temporary_pointer = current->next;
            current->next = current->next->next;
            if (temporary_pointer == tail) {
                tail = current;
            }
            delete temporary_pointer;
            --size;
            return removed_element;
        }


        T get_element() 
        {
            if (current->next == nullptr) {
                throw std::runtime_error("No element to get");
            }
            return current->next->element;
        }


        void go_to_start() 
        {
            current = head;
        }


        void go_to_end() 
        {
            current = tail;
        }


        void go_to_pos(int p_pos) 
        {
            if ((p_pos < 0) || (p_pos >= size)) {
                throw std::runtime_error("Index out of bounds");
            }
            current = head;
            for (int index = 0; index < p_pos; ++index) {
                current = current->next;
            }
        }


        void next() 
        {
            if (current != tail) {
                current = current->next;
            }
            else {
                throw std::runtime_error("There's no next positition");
            }
        }


        void previous() 
        {
            if (current != head) {
                current = search_previous();
            }
            else {
                throw std::runtime_error("There's no previous positition");
            }
        }


        int get_pos() 
        {
            int pos = 0;
            Node<T>* temporary_pointer = head;
            while (temporary_pointer != current) {
                temporary_pointer = temporary_pointer->next;
                ++pos;
            }
            return pos;
        }


        int get_size() 
        {
            return size;
        }


        void concat(Linked_list<T> p_list)
        {
            for (p_list.go_to_start(); p_list.get_pos() < p_list.get_size(); p_list.next()) {
                append(p_list.get_element());
            }
        }

};

模板//实现：链接列表
类链接列表{
私人：
节点*头；
节点*尾部；
节点*电流；
整数大小；
void init（）
{
头部=尾部=当前=新节点（）；
尺寸=0；
}
节点*search_previous（）
{
如果（当前==水头）{
返回空ptr；
}
节点*上一个_节点=头部；
while（上一个节点->下一个！=当前）{
上一个节点=上一个节点->下一个；
}
返回上一个_节点；
}
公众：
链表（）
{
init（）；
}
无效清除（）
{
while（head！=nullptr）{
电流=水头；
头部=头部->下一步；
删除当前文件；
}
init（）；
}
~Linked_list（）
{
清除（）；
删除标题；
}
void append（tpu元素）
{
tail->next=新节点（p_元素）；
tail=tail->next；
++大小；
}
空心插件（T p_元素）
{
当前->下一步=新节点（p_元素，当前->下一步）；
如果（当前==尾部）{
tail=tail->next；
}
++大小；
}
T删除（）
{
如果（当前->下一步==nullptr）{
抛出std:：runtime_错误（“没有要删除的元素”）；
}
T删除的元素=当前->下一个->元素；
节点*临时_指针=当前->下一步；
当前->下一步=当前->下一步->下一步；
if（临时_指针==尾部）{
尾=电流；
}
删除临时_指针；
--大小；
返回移除的元素；
}
无法获取_元素（）
{
如果（当前->下一步==nullptr）{
抛出std:：runtime_错误（“没有要获取的元素”）；
}
返回当前->下一步->元素；
}
无效转到开始（）
{
电流=水头；
}
void gou_to_end（）
{
电流=尾部；
}
无效转到位置（内部位置）
{
如果（（p_pos<0）|（p_pos>=大小））{
抛出std:：runtime_错误（“索引超出范围”）；
}
电流=水头；
对于（int index=0；index下一步；
}
}
作废下一页（）
{
如果（当前！=尾部）{
当前=当前->下一步；
}
否则{
抛出std:：runtime_错误（“没有下一个位置”）；
}
}
作废以前的（）
{
如果（当前！=头）{
当前=搜索前一个（）；
}
否则{
抛出std:：runtime_错误（“没有先前的位置”）；
}
}
int get_pos（）
{
int pos=0；
节点*临时_指针=头；
while（临时_指针！=当前）{
临时指针=临时指针->下一步；
++pos；
}
返回pos；
}
int get_size（）
{
返回大小；
}
void concat（链接列表p列表）
{
对于（p_list.go_to_start（）；p_list.get_pos（）

这里是节点：

template<typename T>
class Node {
    public:
        T element;
        Node<T>* next;


        Node(T p_element, Node<T>* p_next = nullptr)
        {
            element = p_element;
            next = p_next;
        }


        Node(Node<T>* p_next = nullptr)
        {
            next = p_next;
        }
};

模板
类节点{
公众：
T元素；
节点*下一步；
节点（T p_元素，节点*p_next=nullptr）
{
元素=p_元素；
next=p_next；
}
节点（Node*p_next=nullptr）
{
next=p_next；
}
};

我遇到的问题是，当我尝试使用方法

concat

时，我从Clang那里得到以下消息：

证明（13417,0x7fff7bb9f000）malloc:*对象0x7fe10b603170的错误：未分配要释放的指针 *在malloc\u error\u break中设置断点以进行调试 中止陷阱：6

---

我能做些什么来修复它？

明显的错误是：

    void concat(Linked_list<T> p_list)

或提供适当的复制构造函数和赋值运算符

---

请参见

我能做些什么来修复它？

调试代码。

通过值传递void concat（Linked\u list p\u list）

并且您的

Linked\u list

类不遵循3的规则。这是一个灾难的配方。我如何通过引用传递？我已经得到了它，谢谢。将参数声明为引用，则不会进行复制。然而，这只是一个创可贴的方法来解决真正的问题，也就是说，不应该抄袭这个班级。您应该关闭复制（可以根据您是否使用C++ 11或一个或两个方式来执行），或者为您的类提供适当的复制构造函数和赋值运算符。

   void concat(Linked_list<T>& p_list)