C++，删除在函数/迭代过程中定义的动态数组

Question

我正在进行一项作业，其中涉及更新动态数组的大小以存储重复输入，值为 -1 表示输入结束。当我使用这段代码时:

    bool end = false;
    int curr;
    int n = 0;
    int* currArr = new int[n];
    int* temp = NULL;
    while (end == false) {  
        cin >> curr;
        if (curr == -1) {
            end = true;
        }
        else {
            n++;
            int* temp = new int[n];
            temp = currArr;
            temp[n - 1] = curr;
            currArr = temp;
        }
    }
    delete[] currArr;
    delete[] temp;

我是否为 temp 定义一个内存地址，在每次迭代期间更改存储在该地址的内容，然后在最后彻底删除该地址的内容？

或者我是否在每次迭代期间分配一个新的动态数组，只删除最后一次迭代中定义的数组，并泄漏其余部分？如果是这样，我该如何避免？

类似地，如果我在函数中定义一个动态数组，如下所示:

int* fxn(int size) {
    int* x = new int[size];
    return &x[0];
}

int main() {
    int* y = fxn(size);
    delete[] y;
    return 0;
}

我的理解是删除 y 将删除数组，因为 y 指向与 x 在函数中指向的相同地址。如果 fxn 是一个 void 函数，则需要在 fxn 中删除 x，因为 fxn 不会向 main 输出任何信息来定位 x。

我理解正确吗？

谢谢!

Answer 1

每次分配内存，将你之前分配的指针赋给新分配的内存时，你应该删除之前的指针。否则会导致内存泄漏。在您的情况下， curArr 一直指向循环中的新地址，但永远不会删除以前的地址。然后你删除 curArr 和 temp 都会崩溃，因为它们指向同一个位置，所以你要删除同一个指针两次。并在分配后将 temp 分配给 curArray，您只是再次丢失了新分配的指针。所以代码是一个充满漏洞和崩溃的巨大困惑。您最初还分配了大小为 0 的内存，这是未定义的行为。

#include <iostream>
#include <memory>
using namespace std;

int main(){
    bool end = false;
    int curr;
    int n = 1;
    int* currArr = new int[n];
    while (end == false) {
        cin >> curr;
        if (curr == -1) {
            end = true;
        }
        else {
            currArr[n - 1] = curr;
            int* temp = new int[n+1];
            memcpy(temp, currArr, n*sizeof(int));
            delete[] currArr;
            currArr = temp;
            ++n;
        }
    }
    for(int index = 0; index < n-1; ++index){
        std::cout << currArr[index]<< std::endl;
    }
    delete[] currArr;

}

我去除了您代码中的冗余并修复了漏洞。该代码最初将分配大小为 n=1 的内存。然后用户输入 curr 的任何内容都将放在索引 n-1 处。然后使用 temp 分配新内存，大小为 n+1。 curArr 中的先前内存将被复制到新分配的区域中。 curArr 的先前区域将被删除，指针将分配给新区域。

是的。你对第二个问题的理解是正确的。