0

嗨，我通过 valgrind 运行了我的程序，这是报告

堆摘要：退出时使用：1 个块中的 8 个字节 总堆使用量：1 个分配，0 个释放，分配 8 个字节泄漏摘要：肯定丢失：1 个块中的 8 个字节

这是我的程序

int main() {    
NodeData nodedata1(1, 'a');
List list1;
list1.insert(&nodedata1);

   return 0;
}
//---my List class
class List {
public:
   List(); 
   bool insert(NodeData*);                     // insert one Node into list
   bool isEmpty() const; 
private:
   struct Node {              // the node in a linked list
      NodeData* data;         // pointer to actual data, operations in NodeData
      Node* next;
   };
   Node* head;                                 // pointer to first node in list
};
// my bool insert method
bool List::insert(NodeData* rightPtr) {  
   Node* newPtr = new Node;
   newPtr->data = rightPtr;    
   if (isEmpty() || *newPtr->data < *head->data) {
      newPtr->next = head;                           
      head = newPtr;
   }
   else {
      Node* current = head; 
      while (current->next !=NULL && *current->next->data < *newPtr->data) {
           current = current->next;
      }
      newPtr->next = current->next;
      current->next = newPtr;
   }
   return true;
}
4

2 回答 2

4

通过声明它创建的对象将在其范围结束之前被销毁。除非您手动删除它，否则使用new创建的对象不会被销毁。以下示例演示了对象的生命周期。

#include <iostream>
using namespace std;

class Data {
    protected:
        char* name;
    public:
        Data(char* n) {
            name = n;
            cout << name <<  " is created." << endl;
        }

        ~Data() {
            cout << name <<  " is destroyed." << endl;
        }
};

void ScopeDemo() {
    Data obj1("Obj1");
    Data* obj2 = new Data("Obj2");
}

int main()
{
    ScopeDemo();
    return 0;
}

在现代操作系统中，应用程序使用的内存将在应用程序终止时被释放。

在您的示例中，当List对象被销毁（通过对象析构函数）以及从List中删除节点时，您将需要手动删除。

List::~List() {
    if (!isEmpty()) {
        Node* toDelete = head;
        while(toDelete != NULL) {
            Node* next = toDelete->next;
            delete toDelete;
            toDelete = next;
        }
    }
}
于 2012-04-14T09:07:19.183 回答
3

您Node在insert方法中动态分配 a 并且永远不会删除它：

Node* newPtr = new Node;

您需要跟踪这些Nodes并在析构函数中删除它们List，或者有一些其他的安排来处理内存（即将 的所有权传递Nodes给负责在正确时刻删除它们的东西）。

于 2012-04-14T08:26:18.997 回答