Question

如果我有以下程序：

#include <iostream>

// being lazy and using all std just for example.
using namespace std;

int (*some_func())[10]
{
    int arr[10]= {0,1,2,3,4,5,6,7,8,9};

    return arr;
}

int main()
{
    int arr2[10] = some_func();
    for(auto i : arr2)
        cout << i << endl;

    return 0;
}

这是定义返回数组的函数的正确方法吗？我知道我在这里缺少一些重要的东西，我的知识告诉我，当你返回arr时，你得到一个*到arr的第一个元素，但它也告诉我arr是在本地定义的意思是当函数完成时arr将是未定义的因此，当我实际从返回时将arr分配给arr2时，我正在为它分配未定义的内存，这不是我想要的，但如果我返回＆amp; arr并不是基本相同的那样？

任何与上述例子有关的理解都是有用的，似乎我在某处弄糊涂了，但我不太清楚如何纠正它。

谢谢，

Euden

Answer 1

在C ++ 11中，您应该使用容器std::array

#include <iostream>
#include <array>

std::array<int, 10> get_array()
{
    return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
}

int main()
{
    auto arr = get_array();
    for(const auto& elem: arr)
        std::cout << elem << std::endl;
}

为什么更好？

在C ++中，您无法返回数组，您可以返回指向第一个元素的指针。看一下代码：
```
int* array()
{
    // int arr[10]; // <-- DO NOT USE IT!
    int* arr = new int[10]; // Better, but still ugly
    return arr;
}

int main()
{
    auto arr = array();
}
```
但记忆呢？你应该在使用后删除数组，但你可以忘记它。所以，你需要一个智能指针。
```
std::unique_ptr<int[]> array()
{
    std::unique_ptr<int[]> arr(new int[10]);
    return arr;
}
```
注意：两种实现都使用动态分配的数组，而std::array封装静态数组。

您不能像其他对象一样复制或分配数组，您需要迭代一个数组并将数据复制到另一个数组中。 std::array容器允许您忘记它。

int main()
{
    std::array<int, 10> arr1{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}};
    std::array<int, 10> arr2;

    arr2 = arr1;

    arr1.at(4) = 42;

    // arr1: {1, 2, 3, 4, 42, 6, 7, 8, 9, 10}
    // arr2: {1, 2, 3, 4, 5,  6, 7, 8, 9, 10}
}

std::array提供了许多有用的成员函数，例如其他容器，例如 - std::array::at(pos)。
```
int main()
{
    std::array<int, 10> arr;
    arr.at(42) = 42;
}
```
如果pos >= arr.size()。

从C ++中的函数正确定义和返回数组

1 个答案:

为什么更好？