Question

我试图颠倒int - 数组的序列。这是我的代码，它给出了大量的错误。

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

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

Answer 1

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

此处的实例：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

不使用std库：

使用简单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);
}

使用std库（推荐）：

如果可用，如果不在特殊条件下（例如一些家庭作业/作业约束;）），您应该更喜欢标准库算法：

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

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

Answer 4

没有诸如事物返回类型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 
}

如果你问我的最佳选择是第二和第三，如果你可以改变输入则使用第二选项，如果你需要输入和输出则使用第三选项。

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

说明：

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

用C ++反转数组的顺序

5 个答案:

不使用std库：

使用std库（推荐）：