C++ 如果未分配退货，是否需要删除或取消分配动态数组？还是被函数删除了？

由于未分配返回，函数是否删除并释放内存？

---

内存是否需要释放

简短回答：是的，需要删除

如果为对象分配了新对象，则还应将其删除。使用普通指针是容易出错的，并且大量的手工工作，这就是为什么C++有几个智能指针可用，最重要的是。在您的情况下，std:：unique\u ptr可能是一个选项

例如：

#include <iostream>
using namespace std;

int *arrExpand(int *arr, int arrSize)
{
    int *p = new int [arrSize * 2];
    for(int i =0; i < arrSize * 2; i++)
    {   if(i < arrSize)
            p[i] = arr[i];
        if(i > arrSize)
            p[i] = 0;
    }
    return p;
}

int main()
{
    int mySize = 5;
    int myArr[5] = {1,2,3,4,5};

    cout << "Array: ";
    for(auto v: myArr)
        cout << v;
    for( int i = 0; i < mySize * 2; i++)
        cout  << endl << *(arrExpand(myArr,mySize)+i);
    //return is not assigned == delete not needed?
    return 0;
}

在您的示例中可以使用如下内容：

std::unique_ptr<int[]> arrExpand(int *arr, int arrSize)
{
    std::unique_ptr<int[]> p( new int [arrSize * 2] );
    for(int i =0; i < arrSize * 2; i++)
    {   if(i < arrSize)
            p[i] = arr[i];
        if(i > arrSize)
            p[i] = 0;
    }
    return std::move(p);
}

---

请注意，您应该在循环之前存储arexpand的结果一次，否则每次循环迭代都会调用该函数，这是非常低效的。

简短回答：是的，需要删除它

如果为对象分配了新对象，则还应将其删除。使用普通指针是容易出错的，并且大量的手工工作，这就是为什么C++有几个智能指针可用，最重要的是。在您的情况下，std:：unique\u ptr可能是一个选项

例如：

#include <iostream>
using namespace std;

int *arrExpand(int *arr, int arrSize)
{
    int *p = new int [arrSize * 2];
    for(int i =0; i < arrSize * 2; i++)
    {   if(i < arrSize)
            p[i] = arr[i];
        if(i > arrSize)
            p[i] = 0;
    }
    return p;
}

int main()
{
    int mySize = 5;
    int myArr[5] = {1,2,3,4,5};

    cout << "Array: ";
    for(auto v: myArr)
        cout << v;
    for( int i = 0; i < mySize * 2; i++)
        cout  << endl << *(arrExpand(myArr,mySize)+i);
    //return is not assigned == delete not needed?
    return 0;
}

在您的示例中可以使用如下内容：

std::unique_ptr<int[]> arrExpand(int *arr, int arrSize)
{
    std::unique_ptr<int[]> p( new int [arrSize * 2] );
    for(int i =0; i < arrSize * 2; i++)
    {   if(i < arrSize)
            p[i] = arr[i];
        if(i > arrSize)
            p[i] = 0;
    }
    return std::move(p);
}

---

请注意，您应该在循环之前存储arexpand的结果一次，否则每次循环迭代都会调用该函数，这是非常低效的。

如前所述，您确实需要删除[]内存。你可以记住这条简单的规则：

删除你刚更新的所有内容一次。这同样适用于删除[]和新建[]

然而，我不同意智能指针的建议。虽然std:：unique_ptr具有一些优势，如所述，可以替代大型旧代码库中的原始阵列，但更自然的替代方案是：

甚至更好

std::vector<int> arrExpand(int *arr, int arrSize)
{
    std::vector<int> p (arrSize * 2);
    for(int i =0; i < arrSize * 2; i++)
    {   if(i < arrSize)
            p[i] = arr[i];
        if(i > arrSize)
            p[i] = 0;
    }
    return p;
}

---

一般来说，至少我不知道一个反例，使用std:：vector作为标准运行时大小的数组是一个非常好的主意。一个很好的理由是自动和正确的内存管理。它还附带了许多有用的成员函数，包括了解其自身大小。

如前所述，确实需要删除[]内存。你可以记住这条简单的规则：

删除你刚更新的所有内容一次。这同样适用于删除[]和新建[]

然而，我不同意智能指针的建议。虽然std:：unique_ptr具有一些优势，如所述，可以替代大型旧代码库中的原始阵列，但更自然的替代方案是：

甚至更好

std::vector<int> arrExpand(int *arr, int arrSize)
{
    std::vector<int> p (arrSize * 2);
    for(int i =0; i < arrSize * 2; i++)
    {   if(i < arrSize)
            p[i] = arr[i];
        if(i > arrSize)
            p[i] = 0;
    }
    return p;
}

---

一般来说，至少我不知道一个反例，使用std:：vector作为标准运行时大小的数组是一个非常好的主意。一个很好的理由是自动和正确的内存管理。它还附带了许多有用的成员函数，包括了解其自身的大小。

查找：查找：如果未分配删除，我会将其放置在何处？在返回0之前？@tariqebadi这就是使用智能指针的原因：您不必调用delete，它们会处理它。如我所示，当您使用std:：unique_ptr时，您基本上是安全的，即使在异常情况下，也不会发生资源泄漏。如果没有分配删除，我会将其放置在何处？在返回0之前？@tariqebadi这就是使用智能指针的原因：您不必调用delete，它们会处理它。如我所示，当您使用std:：unique_ptr时，您基本上是安全的，并且不会出现资源泄漏——即使在出现异常的情况下也是如此。