C++ Valgrind：将一个指针分配给另一个指针后丢失字节

我正在写一份清单。当我通过valgrind运行程序时，会出现以下错误：

==26620== 
==26620== HEAP SUMMARY:
==26620==     in use at exit: 160 bytes in 10 blocks
==26620==   total heap usage: 14 allocs, 4 frees, 82,632 bytes allocated
==26620== 
==26620== 16 bytes in 1 blocks are definitely lost in loss record 1 of 3
==26620==    at 0x4C2B1EC: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==26620==    by 0x10EC98: List<int>::ListNode::addNext(int) (List.h:20)
==26620==    by 0x10E9AB: List<int>::insert(int) (List.cpp:28)
==26620==    by 0x10BA07: main (main.cpp:62)
==26620== 
==26620== 144 (16 direct, 128 indirect) bytes in 1 blocks are definitely lost in loss record 3 of 3
==26620==    at 0x4C2B1EC: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==26620==    by 0x10E93D: List<int>::insert(int) (List.cpp:18)
==26620==    by 0x10BA07: main (main.cpp:62)
==26620== 
==26620== LEAK SUMMARY:
==26620==    definitely lost: 32 bytes in 2 blocks
==26620==    indirectly lost: 128 bytes in 8 blocks
==26620==      possibly lost: 0 bytes in 0 blocks
==26620==    still reachable: 0 bytes in 0 blocks
==26620==         suppressed: 0 bytes in 0 blocks
==26620== 
==26620== For counts of detected and suppressed errors, rerun with: -v
==26620== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)

==26620==
==26620==堆摘要：
==26620==在出口处使用：10个块中有160字节
==26620==总堆使用率：14个alloc，4个free，分配了82632个字节
==26620== 
==26620==1个块中的16个字节肯定会在丢失记录1（共3个）中丢失
==26620==at 0x4C2B1EC:运算符新（无符号长）（在/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so中）
==26620==by 0x10EC98:List:：ListNode:：addNext（int）（List.h:20）
==26620==by 0x10E9AB:List:：insert（int）（List.cpp:28）
==26620==0x10BA07:main（main.cpp:62）
==26620== 
==26620==1个块中的144（16个直接字节，128个间接字节）字节肯定会在丢失记录3（共3个）中丢失
==26620==at 0x4C2B1EC:运算符新（无符号长）（在/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so中）
==26620==by 0x10E93D:List:：insert（int）（List.cpp:18）
==26620==0x10BA07:main（main.cpp:62）
==26620== 
==26620==泄漏汇总：
==26620==肯定丢失：2个块中有32个字节
==26620==间接丢失：8个块中128字节
==26620==可能丢失：0个块中有0个字节
==26620==仍然可访问：0个块中有0个字节
==26620==抑制：0个块中有0个字节
==26620== 
==26620==对于检测到的和抑制的错误计数，请使用：-v重新运行
==26620==错误摘要：来自2个上下文的2个错误（已抑制：0来自0）

应要求：

清单h

#ifndef CDR_LIST_H
#define CDR_LIST_H

template <typename T>
class List {
private:
class ListNode {
private:
    T entry;
    ListNode *next;
public:
    ListNode(T entry) : entry(entry), next(nullptr) {}
    ~ListNode() {
        if (next != nullptr) {
            delete next;
        }
    }

    void addNext(T entry) {
        this->next = new ListNode(entry); // Here
        setNext(next);
    }

    void setNext(ListNode *next) {
        this->next = next;
    }

    ListNode *getNext() {
        return this->next;
    }

    T getEntry() { return this->entry; }
};

ListNode *root;
int size;
public:
List();
~List();

void deleteList(ListNode *root);

void insert(T entry);

T at(int index);

void deleteAt(int index);

void printList();
};
#endif //CDR_LIST_H

\ifndef CDR\u列表
#定义CDR\u列表
模板
班级名单{
私人：
类ListNode{
私人：
T项；
ListNode*下一步；
公众：
ListNode（T entry）：entry（entry），next（nullptr）{}
~ListNode（）{
如果（下一步！=nullptr）{
删除下一步；
}
}
void addNext（T条目）{
this->next=newlistnode（条目）；//此处
setNext（下一个）；
}
void setNext（ListNode*next）{
这个->下一个=下一个；
}
ListNode*getNext（）{
返回此->下一步；
}
T getEntry（）{返回此->条目；}
};
ListNode*root；
整数大小；
公众：
List（）；
~List（）；
作废删除列表（列表节点*根）；
无效插入（T条目）；
T at（int指数）；
void deleteAt（int索引）；
作废打印列表（）；
};
#endif//CDR\u列表

List.cpp

#include <iostream>
#include "List.h"

template <typename T>
List<T>::List() : size(0) {
this->root = nullptr;
}

template <typename T>
List<T>::~List() {
deleteList(this->root);
}

template <typename T>
void List<T>::insert(T entry) {
if (this->size == 0 || this->root == nullptr) {
    root = new ListNode(entry); // And here
    size++;
    return;
}
ListNode *currNode = this->root;
while (currNode->getNext() != nullptr) {
    currNode = currNode->getNext();
}
currNode->addNext(entry);
this->size++;
}

template <typename T>
T List<T>::at(int index) {
if (index >= this->size) {
    throw std::out_of_range("Index out of list range");
}

ListNode *currNode = this->root;
for (int i = 0; i < index; i++) {
    currNode = currNode->getNext();
}

return currNode->getEntry();
}

template <typename T>
void List<T>::deleteList(ListNode *root) {
if (root == nullptr) {
    delete root;
    return;
}

deleteList(root->getNext());
}

template <typename T>
void List<T>::deleteAt(int index) {
if (index >= this->size) {
    throw std::runtime_error("Index out of range");
}

ListNode *currNode = this->root;
ListNode *parentNode = this->root;
for (int i = 0; i < index; i++) {
    parentNode = currNode;
    currNode = currNode->getNext();
}

parentNode->setNext(currNode->getNext());
// delete currNode;
}

template <typename T>
void List<T>::printList() {
ListNode *currNode = this->root;
while (currNode != nullptr) {
    std::cout << currNode->getEntry() << std::endl;
    currNode = currNode->getNext();
}
}




template class List<int>;

#包括
#包括“List.h”
模板
列表：：列表（）：大小（0）{
此->根=空ptr；
}
模板
列表：：~List（）{
删除列表（此->根目录）；
}
模板
无效列表：：插入（T条目）{
if（this->size==0 | | this->root==nullptr）{
root=newlistnode（条目）；//此处
大小++；
返回；
}
ListNode*currNode=this->root；
while（currNode->getNext（）！=nullptr）{
currNode=currNode->getNext（）；
}
currNode->addNext（条目）；
这个->大小++；
}
模板
T列表：：at（int索引）{
如果（索引>=此->大小）{
抛出标准：：超出范围（“索引超出列表范围”）；
}
ListNode*currNode=this->root；
对于（int i=0；igetNext（）；
}
返回currNode->getEntry（）；
}
模板
void List:：deleteList（ListNode*root）{
if（root==nullptr）{
删除根；
返回；
}
deleteList（root->getNext（））；
}
模板
无效列表：：deleteAt（int索引）{
如果（索引>=此->大小）{
抛出std:：runtime_错误（“索引超出范围”）；
}
ListNode*currNode=this->root；
ListNode*parentNode=this->root；
对于（int i=0；igetNext（）；
}
parentNode->setNext（currNode->getNext（））；
//删除节点；
}
模板
无效列表：：打印列表（）{
ListNode*currNode=this->root；
while（currNode！=nullptr）{
std:：cout getEntry（）getNext（）；
}
}
模板类列表；

我知道我创建的指针是两种情况，但因为我需要它所指向的数据，所以无法删除它们。那么，如何将这些情况视为字节丢失，以及如何避免这种情况

谢谢

---

标记行实际上用相同的值覆盖此->下一步。虽然不会更改实际值，但Valgrind可能会警告您内存泄漏。

发布更多代码。

void addNext(T entry) {
        this->next = new ListNode(entry); // Here
        setNext(next); // this line is unnecessary
}