3

我是 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的解决方案很可能是做事的最佳实践方式，但这并不是我的具体问题

4

7 回答 7

6

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

现在，在你的情况下，

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)

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

于 2012-06-14T09:01:30.693 回答
4

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

您可以返回一个指针或一个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而不是创建自己的函数，但这只是我。

于 2012-06-14T08:58:54.403 回答
2

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

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

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

于 2012-06-14T08:59:09.090 回答
2

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

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

于 2012-06-14T09:00:41.783 回答
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;
}
于 2012-06-14T08:58:37.307 回答
1

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

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

于 2012-06-14T09:12:25.897 回答
0

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

于 2012-06-14T09:05:38.520 回答