Pointer array and array pointer

Pointer arrays and array pointers

1. Pointer array

int arr[5] = {
    0, 1, 2, 3, 4};
int *ptrArr[5] = {
    &arr[0], &arr[1], &arr[2], &arr[3], &arr[4] };
// Another way to express int* ptrArr[5] = {&arr[0], &arr[1], &arr[2], &arr[3], &arr[4] };
cout<<*(ptrArr[3])<<endl;	// Output elements 3

The above figure shows the pointer array , It's essentially an array , There is 5 Elements , Each element is a pointer . This * The number is leaning against int side , Or leaning next to the array name does not affect its nature .

You can see arr The memory address of the array is 0x00cff7e8, There is 5 Elements , The size of an element is 4 byte .

Look at the pointer array , You can see in it 5 A pointer to the , This is because when initializing, we point each pointer to an element .0 The pointer of element No. is 0x00cff7e8, just 0 The location of , And so on .

cout<<*(ptrArr[3])<<endl;	// Output elements 3

First analyze ptrArr[3], Represents the... In the array 4 Elements , That's the pointer 0x00cff7f4,* The value corresponding to dereference is the element 3.

2. Array pointer

    int arr[5] = {
     0,1,2,3,4};
    int (*arrPtr)[5] = &arr;

An array pointer is essentially a pointer , Pointing to the array , The biggest difference with pointer array is that the asterisk and array name are enclosed in parentheses .

Notice that the type above is int*[5], The type here is int[5]*;

cout<<(*arrPtr)[3]<<endl;	// Output elements 3

arrPtr In essence, it is a pointer to an array , Get the array by dereferencing ,(*arrPtr)[3] Is equal to arr[3].

3. A pointer to a two-dimensional array

The memory distribution of the two-dimensional array is as follows .
Hypothetical array a pass the civil examinations 0 The address of the element is 1000, Then the first address of each one-dimensional array is shown in the figure below ：

Next, let's look at the application of array pointers in two-dimensional arrays . This is a choice question of Niuke network , The answer is 10, 20, 30.

From the statement int (*p)[3] With brackets , Enclose the asterisk and the array name , It means this is an array pointer , Point to one 3 Array of elements .

You can see in the memory distribution ,n It represents a 2*3 Array of , and p The declaration of points to a 3 Array of elements , therefore p In essence, it points to the first row of the two-dimensional array . It can also be seen from the above value ,p=n[0], It's all 0x00affea0{10,20,30}.

first p[0][0] Is equal to n[0][0], That's the element 10;

the second *(p[0] + 1), Note here p[0] It's actually n[0],n[0] What is stored is the first address of the first line , That is to say n[0][0] This address , adopt +1 Address offset , In essence, the offset is 4 Bytes （int）, It becomes n[0][1] This address , Value by dereference 20.

Third (*p)[2],p What's left is n[0], therefore (p)[2] Equivalent to n[0][2], So the result is 30.

Expand the .p Pointing to 3 Array of elements , namely int[3], that p+1 Just move forward 34=12 byte , That is, the length of a row in a two-dimensional array , namely p+1 Will cause the pointer to point to the next line . Draw the following equivalent conclusion （from C Chinese language network ）：

a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == ((a+i)+j) == ((p+i)+j)

give an example ,（p+1） It means the 1 Row data , Because using the whole row of data has no practical significance , When the compiler encounters this situation, it will be converted to point to the line No 0 Pointers to elements ; You can see below , First line n[1] My first address is 0000bafbd8. So for a row of data, dereference is to get the address of the first element .

((p+1)+1) It means the first one 1 Xing di 1 The value of the elements . This is a data , So dereference can get that data . Another way is to ,(p[1]+1).