standard conversions: Array-to-pointer conversion

This is the point from ISO :Standard Conversions:Array-to-pointer conversion: $4.2.1

An lvalue or rvalue of type “array of N T” or “array of unknown bound of T” can be converted to an rvalue of type “pointer to T.” The result is a pointer to the first element of the array.

Can any开发者_StackOverflow社区 one explain this, if possible with an example program.

I seen these links already, but i am unable to understand:

Array and Rvalue

I think I may have come up with an example of rvalue of array type

In both C and C++, an array can be used as if it were a pointer to its first element. Effectively, given an array named x, you can replace most uses of &x[0] with just x.

This is how subscripting is able to be used with array objects:

int x[5];
x[2];     // this is the same as (&x[0])[2]

This is also how an array can be passed to a function that has a parameter of pointer type:

void f(int* p);

int x[5];
f(x);     // this is the same as f(&x[0])

There are several contexts in which the array-to-pointer conversion does not take place. Examples include when an array is the operand of sizeof or the unary-& (the address-of operator), when a string literal is used to initialize an array, and when an array is bound to a reference to an array.

int a[6];
int *b = a;

Pointer b points to the a[0], i.e. contains the address of the element a[0].

This means, that you can have the following situation:

int arr[100];
arr[ 0 ] = arr[ 1 ] = 666;
// ..

You can use arr as pointer to int, which points to the first element of the array, for example:

*arr = 123;

and then the array will be: arr = { 123, 666, ... }

Also, you could pass the array to a function, that takes int*:

void f( int* a ) { /* ... */ }

and call it:

f( arr );

It's absolutely the same as calling it like this:

f( &arr[ 0 ] );

That is what The result is a pointer to the first element of the array. means.

Another way, you could use the address of the first element is:

*( &arr[ 0 ] + 1 ) = 222;

this will make the second element in the array with value 222; It's the same as

arr[1] = 222;

and

*( arr + 1 ) = 222;

One example of this is that any array variable will automatically degenerate into a pointer to it's first element when passed to a function which takes a pointer of the array's type.

Take a look at this section from the C-Faq on Arrays and Pointers. This is equally applicable in C++.

void foo(int *a) {
    a[0] = 1;
}

int main(void) {
    int b[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    foo(b);

    printf("b[0] == %d\n", b[0]);
}