如何从函数返回动态分配的数组并正确删除 我是C++新手，内存管理方面有问题。

我有一个函数

a（）

，它调用3个函数（

b（）

，

c（）

，

d（）

），每个函数都返回一个动态分配的

MyClass

对象数组：

void a(){
    MyClass * one=b();
    MyClass * two=c();
    MyClass * three=d();
    //operate with 3 array (one, two and three)
    delete [] one;
    delete [] two;
    delete [] three;
}

MyClass * b(){
    MyClass * array=new MyClass[2000];
    //many operations on array
    return array;
}

MyClass * c(){
    MyClass * array=new MyClass[2000];
    //many operations on array
    return array;
}

MyClass * d(){
    MyClass * array=new MyClass[2000];
    //many operations on array
    return array;
}

在

a（）

中进行多次操作后，我必须删除使用3个函数创建的3个数组。如果我使用上面代码中的3

delete[]

表达式来执行此操作，可以吗

---

我问自己这个问题，因为我认为这个代码能正确地分配所有的东西，但是分析我的C++程序的内存分配，我看不出有什么删除的证据。

< P>对于可靠的内存管理，你应该使用智能指针，如：代码> STD:：UnQuyJPPT。因此，当您的函数返回一个动态分配的值时，它应该将

std:：unique_ptr

返回到该值，以确保该值将被释放

std::unique_ptr<MyClass[]> array(new MyClass[2000]);

std:：unique_ptr数组（新MyClass[2000]）；

---

在你的情况下，你应该考虑使用<代码> STD::vector < /COD>而不是原始数组。

< P>是的，你所做的是正确的。

但是，请注意，手动内存管理容易出现错误，无论是内存泄漏还是双重删除。最好忘记裸

new

，尤其是

delete

，而是使用RAII类来安全地处理这个问题

在您的情况下，应该将指向动态分配数组的指针替换为

std:：vector

<代码> STD:：向量是在C++中拼写“动态分配的数组”的方法。一旦您这样做了，您就会知道向量将负责正确地释放内存，即使在存在异常的情况下也是如此

这就是使用

std:：vector时代码的外观：

void a(){
    auto one=b();
    auto two=c();
    auto three=d();
    //operate with 3 array (one, two and three)

    //nothing to do here, the vectors will deallocate memory correctly when they go out of scope
}

std::vector<MyClass> b(){
    std::vector<MyClass> array(2000);
    //many operations on array
    return array;
}

std::vector<MyClass> c(){
    std::vector<MyClass> array(2000);
    //many operations on array
    return array;
}

std::vector<MyClass> d(){
    std::vector<MyClass> array(2000);
    //many operations on array
    return array;
}

void a（）{
自动一=b（）；
自动二=c（）；
自动三=d（）；
//使用3个阵列（1、2和3）进行操作
//此处无需执行任何操作，向量将在超出范围时正确释放内存
}
std：：向量b（）{
std：：矢量阵列（2000）；
//阵列上的许多操作
返回数组；
}
std:：vector c（）{
std：：矢量阵列（2000）；
//阵列上的许多操作
返回数组；
}
std:：vector d（）{
std：：矢量阵列（2000）；
//阵列上的许多操作
返回数组；
}


至于您为什么看不到释放的影响：由
delete
释放的内存不需要立即返回到操作系统。通常，C++运行时会保持它并使用它来满足程序的未来分配要求。如果您使用
new[]
创建，您应该使用
delete[]
@KillzoneKid是的，您是对的，但是我忘记在我的问题中写它了，但是在代码中我正确地使用delete[]，谢谢您的回答。也许我看不到解除分配的效果，因为你解释了这个原因。对于“动态分配的数组”，我不是指可以动态地增长（缩小）数组，而是指在堆内存上分配使用指向此数据结构的指针。因此，为了实现组合：堆内存+数组，可以动态调整大小，我必须使用如下语法：std:：vector*myArray=newstd:：vector（2000）；“这是真的吗？”安东尼奥：不，当然不是。Just do
std:：vector myArray（2000）。向量的数据总是动态分配的，这也是我在回答中的意思。啊，好吧，如果我创建std:：vector myArray（2000），当myArray超出范围时，会自动调用vector的析构函数和MyClass对象的析构函数吗？但在这种情况下，当myArray超出范围时，我会失去一切。如果我想自由决定何时删除它，我可以使用std:：vector的指针？我很困惑：（@安东尼奥1996年并不是真的；使用<代码> STD：：向量*/CODE）是非常罕见的。动态地分配向量（即，<代码>新的STD:：向量< /代码>）更为罕见。普通C++代码根本不需要像这样的构造。