C ++如何从函数返回数组？答案

【问题标题】：C++ How to return an array from a function?C ++如何从函数返回数组？
【发布时间】：2012-06-17 06:58:21
【问题描述】：

我是 C++ 的新手，在尝试获取一个函数（它需要一个数组）来返回一个数组时遇到了麻烦。该函数是一个非常基本的排序算法，用于大小为 4 的整数数组。我所拥有的如下：

int[] sortArrayAscending(int arrayToSort[3]) {
    int sortedArray[3];
    sortedArray[0] = minOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[1] = lowerMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[2] = higherMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[3] = maxOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    return sortedArray;
}

我认为我对需要使用的语法感到非常困惑（对 min、lower、higher、max 的函数调用都可以正常工作。

非常感谢您的帮助。

谢谢

EDIT2：感谢所有 cmets。感谢@Rook 和@Bob Yoplait 的回答，我现在已经解决了。使用的代码是：

   int* sortArrayAscending(int arrayToSort[4], int sortedArray[4]) {
    sortedArray[0] = minOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[1] = lowerMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[2] = higherMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[3] = maxOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    return sortedArray;
}

int _tmain(int argc, _TCHAR* argv[])
{
    int testNumbers[4] = {8,14,1,27};
    int testSorted[4];
    sortArrayAscending(testNumbers,testSorted);

    for (int i = 0; i < 4; i++) {
        cout << testSorted[i] << endl;
    }

    system("pause");
    return 0;
}

感谢您的所有帮助 - 现在是查找向量的时候了！

PS 我很欣赏@Luchian Grigore 的解决方案很可能是做事的最佳实践方式，但这并不是我的具体问题

【问题讨论】：

改用std::vector<int>。
如果你有 C++11，使用std::array<int,4>。
所有数组或向量的大小都应该是 4，而不是 3。
“问题 [..] 要求数组”？ 这是某种赋值吗？
您的 main 现在创建并泄漏了 4 次数组。循环外计算，循环后删除。

标签： c++ arrays dynamic-memory-allocation dynamic-arrays

【解决方案1】：

使用为 C 数组提供适当值语义的 Boost::Array（或 C+11 中的 std::array）。

boost::array<int,4> sortArrayAscending(boost::array<int,4>7 arrayToSort) 
{
    boost::array<int,4> sortedArray;
    sortedArray[0] = minOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[1] = lowerMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[2] = higherMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[3] = maxOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    return sortedArray;
}

【讨论】：

out_of_bounds for arrayToSort[3]
好吧，OPs的例子也有问题，传入的参数只有3个元素，不是4个。所以这里还是有问题。

【解决方案2】：

编辑：编辑后，您的函数返回一个指向数组的指针。应该可以。

您可以返回指针或std::vector。

请注意，在您的代码中，您会遇到未定义的行为，因为 sortedArray 在方法结束时超出范围，并且内存被释放。

~~我会这样做：~~

std::vector<int> sortArrayAscending(int arrayToSort[4]) {
    std::vector<int> sortedArray(4);
    sortedArray.push_back( minOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]));
    sortedArray.push_back(  lowerMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]));
    sortedArray.push_back( higherMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]));
    sortedArray.push_back( maxOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]));
    return sortedArray;
}

实际上，我不会。我只是使用 std::sort 而不是创建自己的函数，但这只是我自己。

【讨论】：

out_of_bounds for arrayToSort[3]
@Default bah - 复制粘贴 :)
是的，我明白了。尽管这也可能是 OP 问题之一。使用std::vector 作为参数不是很好吗？
我会再次为此 +1 进行最后一次编辑。对于 OPs 问题，显然有一个比使用的更好的解决方案。..
@Default 看到这很可能是一项任务，但我可以理解问题背后的动机:)

【解决方案3】：

您正在返回指向局部变量的指针，这会导致未定义的行为。 sortedArray 是静态分配的数组，具有自动存储持续时间，这意味着一旦离开函数范围，它所在的内存就会被释放。

您应该使用new[] 或更好的方式动态分配它：改用std::vector。如果您选择使用new[] 分配它，请不要忘记在不再需要此内存时调用delete[] 释放它。

还请注意，int sortedArray[3]; 声明了一个大小为 3 个元素的数组，索引从 0 到 2。如果您访问大小为 3 的数组的第 4 个元素（如果您访问内存“经过数组对象的最后一个元素”），行为也未定义 .

【讨论】：

【解决方案4】：

由于这是 C++，建议改用 std::vector<int>：

std::vector<int> sortArrayAscending(int arrayToSort[3]) {    
    std::vector<int> sortedArray(4); // Note 4, not 3.
    sortedArray[0] = ...;
    sortedArray[1] = ...;
    sortedArray[2] = ...;
    sortedArray[3] = ...;

    return sortedArray;
}

请注意，有几个algorithms 已经可用，它们将执行您似乎正在执行的一些任务：

【讨论】：

【解决方案5】：

如果我使用的是现代 C++ 编译器，我可能会使用 std::array<int, 4>。很好地处理边界检查和内存管理以及从函数返回/传递给函数。您还可以在其上使用现有的 STLsort 机制和功能；无需重新发明轮子！

现在，就你而言，

int sortedArray[3];

是一个局部变量，你应该永远不要直接返回对它的引用。你可以这样做：

int* sortedArray = new int[4];
// do stuff
return sortedArray;

（还要注意数组的大小，在您的情况下是 4，而不是 3！）但是在这种情况下，您必须记住在将来的某个时候删除该数组，否则您的应用程序会泄漏内存。

你也可以通过引用传入数组，使用类似的方法

void sort_array(std::array<int, 4>& the_array);

或

void sort_array(int** the_array)

在这些情况下，您可以就地修改数组，或者在完成排序后将答案复制到参数中。

【讨论】：

感谢您的回复 - 但 c++ 抱怨“return sortedArray;”当我尝试使用“int* sortedArray = new int[4];”正确的回报结构是什么？

【解决方案6】：

数组总是通过引用传递给 C++ 中的任何函数。因此，只需将您的数组传递给函数。您的原始数组将被排序，然后您可以在您的程序中使用它。我相信没有必要显式返回数组。

【讨论】：

【解决方案7】：

这和 Java 不同

要么将 sortedArray 作为参数传递给函数

int* sortArrayAscending(int* arrayToSort, int* sortedArray) {
    sortedArray[0] = minOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[1] = lowerMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[2] = higherMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[3] = maxOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    return sortedArray;
}

void toto() {
  int array[4]; // and fill values...
  int sortedArray[4];
  sortArrayAscending(array, sortedArray);
}

或

int* sortArrayAscending(int* arrayToSort) {
    int* sortedArray = new int[4];
    sortedArray[0] = minOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[1] = lowerMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[2] = higherMidOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    sortedArray[3] = maxOfFour(arrayToSort[0],arrayToSort[1],arrayToSort[2],arrayToSort[3]);
    return sortedArray;
}

然后你需要在第二种情况下删除返回的数组。

【讨论】：