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都可以正常工作。

我真的很感激一些帮助。

谢谢

EDIT2：感谢您的所有评论。由于@ 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的解决方案很可能是做事的最佳实践方式，但这不是我的具体问题

Answer 1

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

现在，在你的情况下，

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)

在这些情况下，您可以在适当的位置修改数组，或在完成排序时将答案复制到参数中。

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而不是创建我自己的功能，但那只是我。

Answer 3

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

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

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

Answer 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已经可用，可以执行您出现要执行的某些任务：

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

Answer 6

与Java不同

将sortedArray作为参数传递给func

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

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

Answer 7

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

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

7 个答案: