Question

我是C ++的新手，我的内存泄漏问题很小。我的程序结构非常简单，如下所示，虽然我省略了与问题无关的部分。

int** foo(int sizeOfArray){

     int** arrayToReturn = new int*[sizeOfArray];

     for (int i = 0; i < sizeOfArray; i++) {
           arrayToReturn[i] = new int[2];
     }
     return arrayToReturn;
}

int main() {       
    a = someNumber;                // 'a' can be any value ( < 64)
    int** someArray = foo(int a);
    // Do stuff with someArray
}

基本上，它调用一个返回数组数组的函数。我的问题是，当我的程序调用此函数数千次时，它们会导致内存泄漏，因为因为我使用NEW，所以我需要使用delete。我只是不确定如何删除数组，因为我需要在main函数中使用它们，所以我不能在函数foo中删除它们，但是如何删除它们呢？我尝试删除someArray，但永远不会释放行arrayToReturn[i] = new int[2]中使用的内存。

希望这是有道理的，如果这是一个愚蠢的问题，我很抱歉，感谢您的阅读！

Answer 1

要完全删除数组（包括其中的子数组），您可以执行以下操作：

// Assuming we have an array called 'array'
int** array = foo(bar);

// Iterate through all the sub-arrays and delete them
for (int i = 0; i < sizeOfArray; i++) {    
   delete [] array[i];
}

// Delete the primary array
delete [] array;

此代码存在一些样式问题，有些人可能会试图告诉您永远不要使用原始指针，但我只想以直截了当的方式回答您的问题。

它基本上与您用于创建数组的操作顺序相反。首先你创建了外部数组，然后你遍历并创建了子数组，为了删除你需要首先删除子数组，然后删除最外面的数组。

Answer 2

这不是很好的C ++，我不记得上一次我在很久以前在数组上使用new和delete了。但是，当你正在学习时，你需要知道它是如何工作的，所以继续努力并祝你好运！

这是int s数组的相关代码：

int* foo = new int[20];
// free the array
delete [] foo;

Answer 3

解决这个问题的标准方法是首先采取这条道路。

std::vector is the one stop shop for all your dynamic array needs和std::array stands in for the static array。总而言之，我们得到一个漂亮的二维数组，恰好在内存中是连续的，并且会在它超出范围的瞬间被释放。

#include <vector>
#include <array>

std::vector<std::array<int, 2>> foo(int sizeOfArray){

    return std::vector<std::array<int, 2>>(sizeOfArray);
}

int main() {
    int a = 50; // your number here
    std::vector<std::array<int, 2>> someArray = foo(a);
    // Do stuff with someArray


} //someArray goes out of scope and is destoyed, freeing all of the allocated memory

Answer 4

对于初学者，您必须以相对于其分配的相反顺序删除指针。

您可以编写一个以下列方式执行任务的函数

void free( int **array, int sizeOfArray )
{
    for ( int i = 0; i < sizeOfArray; i++ ) 
    {
        delete [] array[i];
    }

    delete [] array;
}

或者它甚至可以定义为

void free( int ** &array, int sizeOfArray )
{
    for ( int i = 0; i < sizeOfArray; i++ ) 
    {
        delete [] array[i];
    }

    delete [] array;

    array = nullptr;
}

您可以使用标头std::vector中声明的标准类<vector>而不是自行分配和释放内存

例如，您的数组可以定义为

std::vector<std::vector<int>> array( sizeOfArray, std::vector<int>( 2 ) );

在这种情况下，您无需担心释放内存。

Answer 5

请参阅'deleteArray'功能。你几乎必须先删除子数组。然后删除顶级数组。学习记忆管理是一项很好的技能。学习内存管理（使用'new'和'delete'）后，您应该了解STL容器。在实践中，人们将使用STL。

我还添加了一个打印功能，以便您可以看到它的外观。

#include <iostream>

int** foo(int sizeOfArray){
    int** arrayToReturn = new int*[sizeOfArray];

    for (int i = 0; i < sizeOfArray; i++) { 
        arrayToReturn[i] = new int[2];
        for (int j = 0; j < 2; j++){
            arrayToReturn[i][j] = j;
        } 
    } 

    return arrayToReturn;
}

void printArray(int **array, int sizeOfArray){
    for(int i = 0; i < sizeOfArray; i++){
        for(int j = 0; j < 2; j++){
            std::cout << array[i][j] << " "; 

        } 
        std::cout <<  std::endl;
    } 
}

void deleteArray(int **array, int sizeOfArray){
    // Do the inverse of foo
    // Delete the sub arrays (ones with size 2)
    for(int i = 0; i < sizeOfArray; i++){
        delete [] array[i];
    }

    // Then delete the entire array
    delete [] array;
}       

int main(){
    int a = 34;
    int **someArray = foo(a);
    printArray(someArray, a);

    std::cout << someArray << std::endl;

    // Delete pieces of memory
    deleteArray(someArray, a);

    // Readability as well. Set our local reference to NULL
    // Also, will make sure we can't use someArray elsewhere
    someArray = NULL;


    // This 'printArray' call would cause a segfault 
    // printArray(someArray, a);

    return 0;
}

如何删除函数返回的数组

5 个答案: