Указатель на массив указателей понимания проблемы

Question

Это, наверное, глупый вопрос, но я не понимаю, почему это работает:

int** test = new int*[7]; 

int x = 7; 
*(test+1) = &x; 

cout << (**(test+1)); 

тест является указателем на указатель вправо? Второй указатель указывает на массив, верно? В моем понимании мне нужно было бы разыменовать указатель «тест», прежде чем перейти к указателю с массивом.

(*test) // Now I have int* 
*((*test) + 1) // to access the first element. 

Где мое ошибочное мышление?

Answer 1

Непонятно, что вы думаете, что создали указатель на массив из 7 int? Вы этого не сделали. Фактически вы создали массив указателей 7 для int. Таким образом, здесь нет «второго указателя», который указывает на массив. Существует только один указатель, указывающий на первый из 7 указателей (test).

И с *test вы получаете тот первый указатель, который вы еще не инициализировали.Если вы хотите добавить 1 в номер , то, вы бы добавили 1 в случайный адрес. Но если вы добавите 1 в test, вы получите указатель, указывающий на второй указатель массива. И отменяя , что вы получаете тот второй указатель, который вы сделал инициализировать.

---

То, что вы описали бы быть достигнуто с помощью другого синтаксиса

typedef int array[7]; 
array* test = new int[1][7]; 

// Note: "test" is a pointer to an array of int. 
// There are already 7 integers! You cannot make it 
// point to an int somehow. 
*(*test + 1) = 7; 

int *p1 = *test 
int i1 = *(p1 + 1); // i1 is 7, second element of the int[7] 

delete[] test; 

Без использования ЬурейеЕ, это выглядит следующим образом

int(*test)[7] = new int[1][7]; 

То есть, вы создали один- массив элементов, где тип элемента - это 7-элементный массив из int. new возвращает указатель на этот массив. Обратите внимание, что важна скобка: * имеет меньше приоритета, чем [7], так что в противном случае это было бы принято как массив из 7 указателей на целые числа.

Answer 2

Выражение *(test + 1) эквивалентно test[1], поэтому код можно переписать следующим образом:

int** test = new int*[7]; 

int x = 7; 
test[1] = &x; 

cout << *test[1]; 

С test[1] явно указывает на x, *test[1] является 7.

Просто, чтобы быть ясным, выражение **(test + 1) просто эквивалентно *(*(test + 1)), что в свою очередь эквивалентно *test[1].

Answer 3

Пусть

test[0] = 0x12345678; // some pointer value 
test[1] = 0x23456789; // some pointer value 

* тест = 0x12345678;

* тест + 1 теперь 0x12345678 + 1 = 0x12345679;

* or dereference operator has higher precedence than binary +). Таким образом, выражение оценивается в этом порядке.

Однако то, что вы хотели, это проверить [0] = 0x23456789;

Таким образом, правильное выражение, чтобы добраться до test[1] = (*(test + 1))

arr[i] В общем это *(arr + i)

EDIT 2:

дал

int buf[10] = {0, 1, 2}; 
int *p = buf; 

ЬиЕ [0] == р [ 0] == * (p + 0), равным 0.

Обратите внимание, что отлично использовать синтаксис доступа к массиву с выражением lvalue p, даже если он не является типом массива. Фактически выражение buf[0] внутренне переводится компилятором на *(buf + 0).

Answer 4

int ** test = new int * [7];

+------++------++------++------++------++------++------+ 
| int* || int* || int* || int* || int* || int* || int* | 
+------++------++------++------++------++------++------+ 

является эквивалентом массива с Int указателей:

int* test[0] 
int* test[1] 
... 
int* test[6] 

это

int x = 7; 
*(test+1) = &x; 

+------++------++------++------++------++------++------+ 
| int* || &x || int* || int* || int* || int* || int* | 
+------++------++------++------++------++------++------+ 

такая же, как

int x = 7; 
test[1] = &x 

так что теперь один из указателей в ваш оригинальный массив указывает на расположение в памяти х

cout << (**(test+1)); 

такое же, как

cout << *test[1] 

который является значение х (== 7) и которые оба теста [1] и & х пункт.