C++如何从函数中返回一个数组？

Question

我刚接触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等函数调用都正常工作）。

我真的很感激帮助。

谢谢。

编辑2：感谢所有的评论。我现在已经解决了，感谢@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，他的解决方案很可能是最佳实践方法，但那不是我具体问的问题。

- rwb

---

请改用std::vector<int>代替。 - hmjd

如果您使用C++11，请使用std::array<int,4>。 - juanchopanza

所有数组或向量的大小应为4，而不是3。 - interjay

“这个问题要求使用数组”？这是某种任务吗？ - default

你的主函数现在创建并泄漏了数组4次。在循环外计算它并在循环后删除它。 - Michael Anderson

Answer 1

我个人建议如果使用现代的C++编译器，可以使用std::array<int, 4>。它能够很好地处理边界检测和内存管理，并且可以轻松地在函数之间传递和返回。此外，你还可以利用现有的STL sort机制和函数对其进行排序，无需重新发明轮子。

针对您的情况，...

int sortedArray[3]; 

这是一个本地变量，您绝不能直接返回对它的引用。您可以采取以下方式：

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

请注意数组的大小，对于你的情况不是3而是4! 但是在这种情况下，你必须记住在将来某个时刻删除数组，否则你的应用程序将泄漏内存。

你也可以通过引用传递数组，使用以下方法：

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

或者

void sort_array(int** the_array)

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

- Rook

---

谢谢您的回复 - 但是当我尝试使用"int* sortedArray = new int[4];"时，C++会抱怨"return sortedArray;"，正确的返回结构是什么？ - rwb

Answer 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而不是创建自己的函数，但这只是我的个人想法。

- Luchian Grigore

---

arrayToSort[3] 的 out_of_bounds。 - default

@Default bah - 复制粘贴 :) - Luchian Grigore

是的，我明白。虽然这可能也是OP的问题之一。使用std::vector作为参数会很好，不是吗？ - default

我会再次点赞最后的编辑。显然，这里有比使用的解决方案更好的解决方案来解决OP的问题。 - default

@Default 看起来这很可能是一个作业，我可以理解问题背后的动机 :) - Luchian Grigore

Answer 3

您正在返回指向本地变量的指针，这会导致未定义行为。 sortedArray是具有自动存储期限的静态分配数组，这意味着一旦离开函数作用域，其所在的内存将被释放。

您应该使用new[]动态分配它，或者更好地使用std::vector。如果选择使用new[]进行分配，则不要忘记在不再需要此内存时调用delete[]以释放它。

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

- LihO

Answer 4

由于这是C ++，建议使用{{link1：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;
}

请注意，已经有几个算法可用，可以执行您似乎正在执行的某些任务：

• max_element()
• min_element()

- hmjd

Answer 5

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

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;
}

- Joel Falcou

---

arrayToSort[3] 的 out_of_bounds。 （说明：out_of_bounds 表示数组越界的意思，即访问了超出数组范围的元素。） - default

好的，在OP的例子中也存在问题，传递的参数只有3个元素，而不是4个。因此这里仍然存在问题。 - default

Answer 6

这不像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;
}

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

- Bob Yoplait

Answer 7

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

- Swayam