在C ++中反转数组的序列[重复]

Question

我正在尝试反转int-array 的序列。这是我的代码，它给出了一大堆错误。

#include <cstdlib>
#include <iostream>

using namespace std;

int [] reverseArray(int []);

int main(){
    int arr[5] = {3,9,11,2,7};
    int arr2[5] = reverseArray(arr);

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

int [] reverseArray(int param[]){
    int s = sizeof(param)/sizeof(param[0]);
    int j = 0;
    int* a[s];
    for (int i = s ; i >= 0; i--)
    {
        a[j] = param[i];
        j++;    
    }
    return a;
}

我需要将修改后的数组传回主函数。所以请不要建议我 void 自己处理输出的函数。

Answer 1

这是一个使用std::array 类的实现，它的工作方式更像您的预期。如果长度在编译时已知，则 reverse 函数能够获取任何大小和类型的数组。我还修复了您的反向逻辑中的错误。它在第一次迭代时超出了参数数组的范围。

此处的示例：http://ideone.com/UuUQ9c

#include <iostream>
#include <array>
using namespace std;

template<class T, size_t N>
std::array<T, N> reverseArray(const std::array<T, N>& param)
{
    int j = 0;
    std::array<T, N> a;
    for (int i = N - 1 ; i >= 0; i--)
    {
        a[j] = param[i];
        j++;    
    }
    return a;
}

int main()
{
    std::array<int, 5> arr = {3,9,11,2,7};
    std::array<int, 5> arr2 = reverseArray<int, 5>(arr);

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

Answer 2

如果您使用 C++，您可以通过以下方式简化您的解决方案：

    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    reverse(v.begin(),v.end());
    for(auto& e : v)
      cout << e << " ";

http://ideone.com/mDMSmZ

Answer 3

没有诸如事物返回类型int[]，因为未知大小的变量不能位于堆栈上。

您的选择是：

const int* reverse(const int input[],size_t size){
   int* output = new int[size];//needed to be delete 
   ...
   return output;
}  

void reverse(int input_output[],size_t size){
   //use same array for input & output 
}  

void reverse(const int input[], int output[],size_t size){
   //get output as out parameter 
}  

如果你问我最好的选择是第 2 和第 3，如果可以更改输入，请使用第 2，如果需要输入和输出，请使用第 3。

Answer 4

不使用标准库：

仅使用int[] 类型并且没有动态分配，您不能将其作为返回值，因为生成的int[] 的大小在编译类型中是未知的。您仍然可以执行以下操作，获得相同的结果：

void reverse(const int a[], int size, int arr[]){
   int tmp, i;
   for (i=0; i < size; i++){
      arr[i]=a[i];
   }
   for (i = 0; i < size/2; ++i) {
      tmp = arr[size-i-1];
      arr[size-i-1] = arr[i];
      arr[i] = tmp;
   }
}

int main(){
   int size=5;
   int source[] = {3,9,11,2,7};
   int destination[size];
   reverse(source, size, destination);
}

使用标准库（推荐）：

如果可用并且如果不是在特殊条件下（例如一些家庭作业/作业限制；））你应该更喜欢标准库算法：

int a[]= {...};
const int size = sizeof(a)/sizeof(int);
int b[size];

std::reverse_copy(a, a+size, b);

Answer 5

我尝试对您的代码应用最小的更改。这是有效的方法：

#include <cstdlib>
#include <iostream>

using namespace std;

int * reverseArray(int, int []);

int main(){

    int arr[5] = {3,9,11,2,7};
    int sz = sizeof ( arr ) / sizeof ( arr[0] );
    int * arr2 = reverseArray(sz, arr);

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


}

int * reverseArray(int s, int param[]){

    int j = 0;
    int * a = new int[s];
    for (int i = s - 1 ; i >= 0; i--)
    {
        a[j] = param[i];
        j++;
    }

    return a;
}

解释：

• 数组通过指针传递给函数。所以，你无法确定它的大小。您必须事先确定大小并将大小作为函数参数传递。
• 分配数组的方式是函数本地的。您需要分配动态内存才能将其传回。