Reverse the sequence of an array in C++

Question

I'm trying to reverse the sequence of an int-array. Here's my code which gives a truckload of errors.

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

I need to pass the modified array back to the main function. So please don't suggest me void functions that handles the output themselves.

Answer 1

Here is an implementation using std::array class which works more like you expect. The reverse function is able to take arrays of any size and type, provided the length is known at compile-time. I also fixed a bug in your reverse logic. It went out of bounds on the param array on the first iteration.

Live example here: 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

If you are using C++ you can simplify your solution with:

    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

Without using the std library:

Using simply int[] type and without dynamic allocation you can't have it as return value, because the size of resulting int[] is unknown at compilation type. You can still do the following, obtaining the same result:

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

Using the std library (recommended):

If available and if not in special conditions (e.g. some homework/assignment constraint ;) ) you should prefer std library algorithms:

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

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

Answer 4

No such as thing return type int[], because unknown size variable can't be located on stack.

Your options are:

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 
}  

Best options if you ask me are the 2nd and the 3rd, use the 2nd if you can change the input, use the 3rd if you need both input and output.

Answer 5

I tried to apply minimal changes to your code. Here is something that worked:

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

Explanation:

• The array is passed to function by pointer. So, you cannot determine its size in there. You will have to determine the size beforehand and pass the size with as a function parameter.
• The way you allocated array is local to the function. You need to allocate dynamic memory to be able to pass it back.