[] указатели операции с

Question

int x[4] = {12, 20, 39, 43}, *y;  y = x; Assume each expression is evaluated after the previous one (take all previous ones in consideration) 
*y + 1 
*(y + 1) y += 2; 
*y = 38 
*y - 1 
*y++ 
*y 
y[0] [Hint: y is not pointing to x[0] anymore so think about it and search for what it means] 

Тут вопрос я пытаюсь решить

1: что у [0] означает?

Я искал в Интернете и ничего не нашел!

2: (* y-1) - операция, проведенная слева направо? будет ли y указывать на элемент перед тем, который он указывает на него сейчас?

спасибо

Answer 1

Указатель - это адрес в памяти.

Если у вас есть int*, это адрес int.

Теперь у вас есть два разных способа доступа к значению по этому адресу.

int a = 1; 
int *ptr = &a; // ptr is the address of a 

printf("%d\n", *ptr); // should print "1" because *ptr is the content at the address stored in ptr 

Теперь, когда мы работаем с массивом, этот синтаксис не так легко читать, так что есть другой синтаксис, который:

int array[4] = { 21, 42, 84, 64 }; 
// Here array is also an address, the address of the first element 

printf("%d\n", array[1]); // this should print "42" 

В самом деле, когда вы используете синтаксис массива aka array[1], это точно так же, как если бы вы делали *(array + 1).

Именно поэтому первый элемент массива [0], потому что это похоже на то, что вы делали *(array + 0).

Итак, если у вас есть указатель (или массив, это то же самое), *ptr == ptr[0].

вложу каждый ответ на свой вопрос на примере:

int x[4] = {12, 20, 39, 43}, *y; 
y = x; 
*y + 1; // 13 
*(y + 1); // 20 (same as y[1]) 
y += 2; // y is now the address of 39 
*y = 38; // { 38, 43 } 
*y - 1; // 37 
*y++; // 43 (y++ then *y) 
*y; // 43 
y[0]; // 43 

Символ «*» оператор применяет на весь блок справа от него. *y + 1 is like y[0] + 1 и *(y + 1), как у [1] `

Когда вы увеличиваете указатель (делая ptr += 2 или ptr++), адрес фактически увеличивается на размере элемента.

int y = 42; 
int *ptr = &y; 

ptr += 2; // ptr is now 8 bytes (2 * syzeof(int)) further &y 

EDIT: Если вы хотите более подробную информацию о приоритетах оператора, вы также можете посмотреть по этой ссылке. http://en.cppreference.com/w/c/language/operator_precedence

Answer 2

Давайте идти через этот шаг за шагом:

int x[4] = {12, 20, 39, 43}, *y; 

Это объявляет и инициализирует массив из 4 целочисленных значений х. Он также объявляет y и резервирует пространство для хранения адреса y.

y = x; 

Что происходит здесь в том, что массив х заглохла на указатель, ссылающийся на адрес первого элемента х; в коде:

y = &(x[0]); 

Следующая:

*y + 1; 

Это выражение является формой арифметики указателей и оценивается справа налево; во-первых, он добавляет 1 к y (y теперь указывает на x [1]), то это разыгрывает y. Обратите внимание, что в конце выполнения инструкции восстанавливается исходное значение y: значение никогда не сохранялось. (Это будет отличаться от операторов инкремента.)

Следующее выражение функционально одинаково (но намного яснее).

y += 2; 

Это продвигает y на 2 смещения; это эквивалентно записи следующего: (теперь у указывает на адрес х [2])

y = y[2]; 

Следующая:

*y = 38; 

у в данный момент указывает на адрес х [2]. Значение x [2] перезаписывается, поскольку мы разыменовали указатель на этот адрес и присвоили ему новое значение. x [2] теперь составляет 38 вместо 39.

*y - 1; 

Опять же, арифметика справа налево; возвращаемое значение - это адрес x [1], но значение теряется, поскольку оно не хранилось нигде.

*y++; 

y теперь указывает на x [3]. Функция разыскивает значение, сохраненное в x [2] (обратите внимание, что y назначается ПОСЛЕ завершения выражения), но это значение не используется.

*y; 

Это просто разногласия, но ничего не делает само собой.

y[0]; 

Функционально эквивалентно предыдущему утверждению; он дает результат, сохраненный в x [3];