4

我已经很好地查看了有关此主题的其他一些问题，并且（据我所知）没有一个解决如何正确地从包含动态分配内存的 stl 对象列表中删除项目与不包含动态分配内存的 stl 对象列表包含动态分配的内存。

我想使用对象列表。以这个对象为例（它不包含动态分配的内存）：

class MyPoint {

public:
    MyPoint(int _x,int _y)
    {
        x = _x;
        y = _y;
    }

private:
    int x;
    int y;

};

所以我可能会创建一个对象列表（不是指向它们的指针），向其中添加内容，然后删除一个元素：

list<MyPoint> myList;

myList.push_back(MyPoint(3,4));
myList.push_back(MyPoint(1,2));
myList.push_back(MyPoint(8,8));
myList.push_back(MyPoint(-1,2));

list<MyPoint>::iterator it;

it = myList.begin();
advance(it,2);
myList.erase(it);

我的列表现在包含： (3, 4) (1, 2) (-1, 2)

  • 问题 1a：我需要对擦除的对象做任何其他事情还是会处理内存？

  • 问题 1b：如果程序结束，我需要对列表中剩余的对象做些什么吗？我是否需要将它们全部删除并以某种方式处理它们的内存？

好的，现在考虑该类的另一个版本，它允许 N 维空间中的一个点。即，我可以动态分配一个长度为 N 的数组来保存类中的 N 个点（我已经为您省去了实现，因为这里没有问题）。然后类的析构函数将使用“delete”删除动态分配的数组。

class MyDynamicPoint {

public:
    MyDynamicPoint(int N)
    {
        points = new int[N];
    }

    ~MyDynamicPoint()
    {
        delete points;
        points = NULL;
    }

private:
    int *points;
};

我现在可以创建一个指向对象的指针列表，而不是对象本身：

list<MyDynamicPoint*> myList;

myList.push_back(new MyDynamicPoint(8));
myList.push_back(new MyDynamicPoint(10));
myList.push_back(new MyDynamicPoint(2));
myList.push_back(new MyDynamicPoint(50));

list<MyDynamicPoint*>::iterator it;

it = myList.begin();
advance(it,2);
myList.erase(it);

  • 问题 2a - 以上是否正确？即因为这个新版本的类将包含一些动态分配的内存，这是否意味着我必须创建一个指向对象的指针列表，而不是对象本身？

  • 问题 2b - 鉴于我刚刚从列表中删除了指针，我应该在哪里调用 delete 来处理对象中现在要删除动态内存的事实？还是stl list的erase方法调用对象的析构函数，照顾它？

非常感谢您的帮助，

最好的，

亚当

4

4 回答 4

4

当你有一个类的数据成员具有自动存储持续时间（即它们的生命周期与此类的实例相关联）时，如下所示：

class MyPoint {
private:
    int x;
    int y;
};

并且您将使用list<MyPoint> myList;，那么这个实例std::list也是一个具有自动存储持续时间的对象，它将在容器被销毁时自动清理，它所包含的元素也是如此。一切都得到照顾。

但是后一个版本不是很幸运的选择……不仅你有一个保存指针的容器，你甚至决定创建一个Point将动态分配的类的数据成员。首先请注意，通过调用分配的所有内容都new应该通过调用释放，通过调用delete分配的所有内容都new[]应该通过调用释放delete[]。

在这种情况下，您在构造对象时分配内存并在对象被破坏时清理它：

MyDynamicPoint(int N)
{
    points = new int[N];
}
~MyDynamicPoint()
{
    delete[] points;
    points = NULL;
}
private:
int *points;

您可以通过使用一些std::vector或std::array代替 C 样式的数组来实现相同的目的，并且您不必自己处理内存管理：

MyDynamicPoint(int N) : points(std::vector<int>(N, 0)) { }

private:
std::vector<int> points;

该std::vector对象将为您处理内存管理。

最后一件事：当您动态分配一个元素并将其存储到容器中时：

myList.push_back(new MyDynamicPoint(8));

您需要自己释放此内存，从列表中删除指针是不够的：

list<MyDynamicPoint*>::iterator it;
...
delete *it;
myList.erase(it);

因此，无论您想实现什么，如果情况允许，请始终首选具有自动存储持续时间的对象。没有什么比被迫手动处理内存管理并在以后处理诸如内存泄漏等令人不快的问题更糟糕的了。

于 2013-03-16T14:52:12.037 回答
3

问题 1a：我需要对擦除的对象做任何其他事情还是会处理内存？

你不需要做任何事情。

问题 1b：如果程序结束，我需要对列表中剩余的对象做些什么吗？我是否需要将它们全部删除并以某种方式处理它们的内存？

你不需要做任何事情。

问题 2a - 以上是否正确？

代码不正确。你违反了三法则。特别是，自动生成MyDynamicPoint的复制构造函数和赋值运算符将按位复制points指针。如果你复制 的一个实例MyDynamicPoint，你最终会得到两个共享同一个points指针的对象：

  • 当其中一个对象超出范围时，另一个对象将变得不可用。
  • 当第二个对象超出范围时，它的析构函数将尝试释放已经被释放的内存。这是未定义的行为。

即因为这个新版本的类将包含一些动态分配的内存，这是否意味着我必须创建一个指向对象的指针列表，而不是对象本身？

不，不是那个意思。事实上，您可能应该继续按值存储对象。但是，您确实需要修复三法则。

问题 2b - 鉴于我刚刚从列表中删除了指针，我应该在哪里调用 delete 来处理对象中现在要删除动态内存的事实？还是stl list的erase方法调用对象的析构函数，照顾它？

由于您有一个原始指针列表，因此不会自动调用析构函数。解决这个问题的最简单方法是按值存储对象，或者使用std::unique_ptrorstd::shared_ptr代替原始指针。

于 2013-03-16T14:53:14.040 回答
0

我认为以下应该有效

MyPoint* ptr = myList.back();

delete ptr;

myList.pop_back();

或者

MyPoint* ptr = myList.back();

delete ptr;

myList.erase(ptr);
于 2013-11-06T04:47:06.837 回答
0

对于问题 1，您无需执行任何操作。当您按值存储对象时，编译器和库将处理所有内容。

但是，当您像第二种情况一样存储指针时，您需要使用delete已分配的那些指针new，否则您将发生内存泄漏。

而且您必须在擦除之前删除指针，因为这会使迭代器无效：

delete *it;
myList.erase(it);
于 2013-03-16T14:51:06.837 回答