在C++中反转数组的顺序

Reverse the sequence of an array in C++

本文关键字：数组 顺序 C++      更新时间：2023-10-16

我正在尝试反转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;
}

我需要将修改后的数组传递回主函数。因此，请不要建议我使处理输出的函数失效。

下面是一个使用std::array类的实现，它的工作方式更符合您的期望。reverse函数可以接受任何大小和类型的数组，前提是在编译时长度已知。我还修复了反向逻辑中的一个错误。它在第一次迭代时超出了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;
    }
}

如果您使用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

没有类似的返回类型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 
}

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

不使用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库（推荐）：

如果可用，并且没有特殊条件（例如一些家庭作业/作业限制；），您应该更喜欢std库算法：

int a[]= {...};
const int size = sizeof(a)/sizeof(int);
int b[size];
std::reverse_copy(a, a+size, b);

我试图对您的代码应用最小的更改。以下是行之有效的方法：

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

说明：

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