在 C++ 中释放与结构关联的所有内存

Question

我有一个结构，其中包含一些向量，定义如下：

#include <vector>
using namespace std;

struct data{
    vector<float> x;
    vector<float> y;
    vector<float> z;
}

我后来这样使用：

data d;
for(int i; i<3; i++){
    d.x.push_back(i)
    d.y.push_back(i*2)
    d.z.push_back(i*3)
}

现在我想以一种完全释放与其关联的所有内存的方式安全地删除data 。 我认为这样做的方法是编写一个简单的析构函数，清除和释放data每个字段，然后delete对象：

struct data{
    vector<float> x;
    vector<float> y;
    vector<float> z;

    ~data(){
        vector<tempObject>().swap(x);
        vector<tempObject>().swap(y);
        vector<tempObject>().swap(z);
    }
}

然后这应该有效：

data d;
    for(int i; i<3; i++){
        d.x.push_back(i)
        d.y.push_back(i*2)
        d.z.push_back(i*3)
    }
delete data;

我在这里使用了最重要的答案来解除分配向量。

这会起作用吗？ 如果没有，您能否描述原因和/或提出替代方案？ 我知道一旦d离开范围，内存就会被释放，但我需要在这之前释放内存。

Answer 1

当struct被销毁时，其成员将被销毁（以与声明相反的顺序）。 这样被销毁的vector s 将清理自己的内存。

不需要自定义析构函数。

Answer 2

现在我想以一种完全释放与其关联的所有内存的方式安全地删除数据。

在 C++ 中有具有自动、静态和动态存储持续时间的变量。 您在示例中拥有的自动存储持续时间和静态存储持续时间的生命周期由编译器控制，因此您无法更改它们的生命周期（一个小例外是通过引用延长右值，但这与此处无关）。 如果您需要手动控制生命周期，则需要创建一个具有动态存储持续时间的变量：

auto d = std::make_unique<data>();
d->x.push_back(1.0);
...
d.reset(); // terminate of lifetime of variable pointed by d manually

Answer 3

不需要删除，因为你有“data d”作为堆栈对象。

vector （因为大多数其他 stl 容器会为您处理清理工作）。

您也不需要结构的自定义析构函数

如果您使用现代 C++ 并在 shared_ptr 或 unique_ptr 上管理堆对象，则您（几乎）永远不需要使用关键字 new 和 delete。

例子：

#include <vector>
#include <memory>

struct MyData
{
    std::vector<float> x;
    std::vector<float> y;
    std::vector<float> z;
};

int main()
{
    //example 1: stack object
    {
        MyData d;
        for(int i = 0; i<3; i++)
        {
            d.x.push_back(i);
            d.y.push_back(i*2);
            d.z.push_back(i*3);
        }
    } // scope of d ends, everything including the vectors are cleaned up


    //example 2: heap object  
    {
        std::unique_ptr<MyData> dataPtr = std::make_unique<MyData>();
        for(int i = 0; i<3; i++)
        {
            dataPtr->x.push_back(i);
            dataPtr->y.push_back(i*2);
            dataPtr->z.push_back(i*3);
        }
    } // scope of dataPtr ends, everything will be cleaned up

    //example 3: heap object, clean up within scope
    {
        std::unique_ptr<MyData> dataPtr = std::make_unique<MyData>();
        for(int i = 0; i<3; i++)
        {
            dataPtr->x.push_back(i);
            dataPtr->y.push_back(i*2);
            dataPtr->z.push_back(i*3);
        }

        dataPtr.reset(); // this will clean-up whatever the pointer points to

    } // scope of dataPtr ends, ptr itself is destoryed

}