关于指针指针的困惑

Question

I am a bit confused about pointers to pointers and wasn't able to find desired results due to Google omitting out some symbols. What does the below statement actually mean

int** arr[10];

Is it an array of 10 double pointers or is it pointer to array of 10 integer pointers(or both the statements are same).

What does the below statement depict?

*arr[0] = new int(5); //assign the first pointer to array of 10 pointers a memory of 5?

And is the first statement equivalent to

int* (*arr)[10];

It would be appreciated if someone clears my doubts. Thanks!

Answer 1

What does the below statement actually mean

It means an array of pointer to pointer to int . There are exactly 10 elements in the array, and each element has a type of int** .

What does the below statement depict?

It first accesses the first element in the array and then dereferences it to access the int* . The int pointer pointed to by the first element is assigned to point at the newly allocated memory. The newly allocated memory holds a value of 5 .

And is the first statement equivalent to int* (*arr)[10];

No, not at all. int* (*arr)[10]; is a pointer to an array of int* . In other words it isn't an array, it is a pointer to an array, and the array that it points to contains 10 elements which are all int* .

Answer 2

The [] notation has precedence over * when you make declarations. So something like

int* arr[10];

is actually an array of 10 pointers to integers even though read from left to right it naturally looks like a pointer to an array.

However if you adjust the precedence like so:

int (*arr)[10];

You get a pointer to an array of ten integers.

In your case int** arr[10]; is an array of 10 pointers to pointers. And it is not equivalent to int* (*arr)[10]; as the latter is a pointer to an array of 10 integer pointers (essentially in the former case you have an array whereas in the latter a pointer, a very important difference).

Maybe the C++ experts could chime in on your question regarding new .

Answer 3

35 <---- I am a pointer to an int


35 <---- I am pointer to an int <---- I am a pointer to an int pointer

This code:

int** arr[10];

declares an array of 10 of those pointers on the far right up there.

int** arr[10];

int num = 35;
int* pint = #
int** ppint = &pint;
arr[0] = ppint;

int** ppint2 = new int*[5];
int num2 = 35;
int num3 = 45;
*ppint2 = &num2;
*(ppint2 + 1) = &num3;
cout << **ppint2 << " " << **(ppint2 + 1) << endl;

--output:--
35 45


int* pint2 = new int[3];
int* pint3 = new int[2];

*pint2 = 10;
*(pint2 + 1) = 20;
*(pint2 + 2) = 30;

*pint3 = 100;
*(pint3 + 1) = 200;

arr[0] = &pint2;
arr[1] = &pint3;

cout << **arr[0] << endl;
cout << *(*arr[0] + 1) << endl;

--output:--
10
20

A pointer is a variable that stores a memory address. So let's say you have the int 10 stored at the address 1A. You can create a pointer variable to 10, and the pointer variable's value will be 1A. Of course the pointer's value has to be stored in memory somewhere, and therefore you can create another pointer that stores the address of where the first pointer's value is located in memory. You do that by assigning the address of the first pointer to the second pointer. The first pointer's type is int*, and the second pointer's type is int**, ie the second pointer is a pointer that stores the address of an int pointer.

*arr[0] = new int(5);

arr[0] is a pointer that stores the address of where some other pointer is located
*arr[0] says, "Get the other pointer, please"
*arr[0] = new ... assigns the address returned by new to the other pointer.

Answer 4

OK, let's take this one question at a time.

int** arr[10]; is an array of 10 pointers that point to integer pointers. Declarations in C++ can generally be read more easily right-to-left. Note that arr is an array, not a pointer -- though it can "decay" into a pointer to its elements (which would be of type int*** ).

*arr[0] = new int(5); involves a few steps. First, an integer is allocated on the heap (that's what new does). It is initialized with the value 5 (the (5) bit calls the "constructor" of int ). new returns a pointer ( int* ) to the location of this newly allocated int in memory. This pointer is assigned to the pointer being pointed to by the first pointer-to-pointer in arr -- the * dereferences the first element for the assignment.

int* (*arr)[10]; is somewhat more exotic, and is not equivalent; it seems to declare a pointer to an array of 10 int pointers ( source ).

Answer 5

A good trick to decipher statements like this is to take it step by step and build up

this is an array of doubles

double array[5];

array is also a pointer so this is the same (however the first one the size is known to be five in the second it could point to any number)

double *array;

`

now lets try something more general

T *a; is a pointer to one or more Ts so is T a[x]; where x is a number

building up T **a; here a is a pointer to one or more pointers that point to one or more Ts

that means that *a is a pointer to one or more Ts and something like

*a = new T[5] is valid however a = new T[5] is not a correct one would be a= new T*[5] that creates 5 pointers to Ts

So back to your original examples int ** arr[10]; here arr points to a static array of 10 int ** that means arr[0] = new int*[5] is a valid statement the following is valid C++

    int ** arr[10];

arr[0] = new int*[5];
arr[0][1] = new int[5];
arr[0][1][0] = 4;

std::cout << arr[0][1][0] << std::endl; // prints 4

delete [] arr[0][1];
delete [] arr[0];
    //note that arr doesn't need to be deleted as it wasn't dynamically allocated