Array and pointer

Question

I am wondering how come the # number1 code not working as I am trying to use increment operator to display the next following element in the array.

But the # number2 code works , and it was the same code but in a function

//# number 1 code
using namespace std;

int main(){
    int arrays[5]={2,4,6,8,10};

    for(int x=0;x<5;x++){
        cout<<*arrays<<endl;
        arrays++;    //error: lvalue required as increment operand
    }
}


//# number 2 code
using namespace std;

void display(int *arr,int size){
    for(int x=0; x<5;x++){
        cout<<*arr<<endl;
        arr++;    //This time no error!!!
    }
}

int main(){
    int arrays[5]={2,4,6,8,10};

    display(arrays,5);
    return 0;
}

A pointer value (the address of pointee) may be incremented. Although, the array decays to a pointer for nearly everything, it still is an array and (the address) may not be incremented. Assigning `arrays` to a corresponding pointer in `main()`, it would work as well. May be of interest: [SO: Arrays are Pointers?](https://stackoverflow.com/a/3960723/7478597). — Scheff's Cat, Apr 23 '19 at 05:21

score 3 · Answer 1 · answered Apr 23 '19 at 05:28

That's because you cannot change the address of an array. In # number 1 code when you do array++, you are actually trying to operate directly on the variable which is storing the base address of the array. What you can try instead is something like below:

int *p = array;
p++;

Whereas in the case when you are calling a function passing the array's base address # number 2, you are implicitly doing what has been shown in the above code snippet.

score 1 · Answer 2 · answered Apr 23 '19 at 05:32

This is a common problem for beginners. Arrays are not pointers!. Arrays are implicitly converted to pointers. That is where the confusion lies. Consider this:

int array[] = {1, 2, 3};
std::cout << *array << '\n';

What do you think is happening when we do *array. Does it really make sense to dereference an array? The array is being implicitly converted to a int * and then dereferenced. What about this:

int array[] = {1, 2, 3};
array++;
std::cout << *array << '\n';

This doesn't compile (as you found out for yourself). In this statement array++, the array is not implicitly converted to a pointer.

Arrays are converted to pointers when you pass them to functions that accept pointers. That makes it possible to do this:

int array[3] = {1, 2, 3};
display(array, 3);

An array is a sequence of objects stored on the stack. You access this sequence of objects as a pointer to the first object. Both arrays and pointers can be subscripted. They share many similarities but are fundamentally different.

To make your first example compile, subscript the array with x:

for (int x = 0; x < 5; x++) {
  std::cout << arrays[x] << '\n';
}

Yash · Answer 3 · 2019-04-23T05:33:18.220

0

Use :

int *arr = arrays;
arr++;

in code #1. It will work. This is because you need first to create a pointer to the base of the array which you can increment as in the second code, you have the pointer in the form of the passed argument to the function.

edited Apr 23 '19 at 05:33

answered Apr 23 '19 at 05:25

Yash

3,438
2
17
33

Array and pointer

3 Answers3