c++ reverse Array elements using dynamic Allocation Operators

Question

Hi i'm the beginner of c++. This time, I try to reverse Array 's element-order using dynamic Allocation Operator. For example an array{1,2,3,4} will be rearranged {4,3,2,1} through calling function 'reverseArray'. Everything works fine but somehow i got unwanted integer '-1' along with rearranged Array. For example {-1,4,3,2,1}. It means i did wrong and i really want to learn my fault. Here is my code, please help me to figure out.

#include<iostream>
#include<new>

using namespace std;

void reverseArray(int [] , int);

int main(){

    int num=0;

    cout << "enter size of pointer : " ;
    cin >> num ;

    int *pointerArray = new int [num];

    cout << "enter integer numbers in pointer" << endl;

    for(int index = 0 ; index < num ; index++){
        cin >> pointerArray[index];     
    }

    reverseArray(pointerArray, num);

delete[] pointerArray;
    return 0 ; 
}

void reverseArray(int reverse[], int Size){
    int*ptArray[Size]; 

    cout << "the reverse order of entered numbers is : " << endl;
    for(int index = 0 ; Size >= 0 ; index++) {
        ptArray[index] = &reverse[Size];
        cout << *ptArray[index] << " " ;
        --Size; 
    }

    return ; 
}

Answer 1

This function

void reverseArray(int reverse[], int Size){
    int*ptArray[Size]; 

    cout << "the reverse order of entered numbers is : " << endl;
    for(int index = 0 ; Size >= 0 ; index++) {
        ptArray[index] = &reverse[Size];
        cout << *ptArray[index] << " " ;
        --Size; 
    }

    return ; 
}

does not make sense.

For starters variable length arrays

    int*ptArray[Size]; 

is not a standard C++ feature.

Secondly in this loop

    for(int index = 0 ; Size >= 0 ; index++) {
        ptArray[index] = &reverse[Size];
        cout << *ptArray[index] << " " ;
        --Size; 
    }

there is access beyond the arrays.

For example let's assume that Size is equal to 1. In this case within the ,loop we have

ptArray[0] = &reverse[1];

and then

ptArray[1] = &reverse[0];

However the only valid index for such arrays is 0.

It is unclear what you are trying to do.

If you want to reverse an array in place then the function can look like

void reverseArray( int a[], size_t Size )
{
    for ( size_t i = 0; i < Size / 2; i++ )
    {
        // you can use the standard function std::swap here
        int tmp = a[i];
        a[i] = a[Size - i - 1];
        a[Size - i - 1] = tmp;
    }
}

And in main after calling the function you can output the reversed array .

Pay attention to that there is standard algorithm std::reverse that can do the rask.

You could just write

std::reverse( reverse, reverse + num );

Here is a demonstrative program.

#include <iostream>
#include <algorithm>

void reverseArray( int a[], size_t Size )
{
    for ( size_t i = 0; i < Size / 2; i++ )
    {
        // you can use the standard function std::swap here
        int tmp = a[i];
        a[i] = a[Size - i - 1];
        a[Size - i - 1] = tmp;
    }
}

int main() 
{
    const size_t N = 5;
    int *a = new int[5] { 1, 2, 3, 4, 5 };

    for ( size_t i = 0; i < N; i++ ) std::cout << a[i] << ' ';
    std::cout << '\n';

    reverseArray( a, N );

    for ( size_t i = 0; i < N; i++ ) std::cout << a[i] << ' ';
    std::cout << '\n';

    std::reverse( a, a + N );

    for ( size_t i = 0; i < N; i++ ) std::cout << a[i] << ' ';
    std::cout << '\n';

    delete [] a;

    return 0;
}

Its output is

1 2 3 4 5 
5 4 3 2 1 
1 2 3 4 5