Указатель на переменную указателя, означающую C [duplicate]

Если вы хотите, чтобы ipp указывал на ip2, вам нужно сказать ipp = &ip2;. Однако это оставило бы ip1 все еще указывая на i.

ipp = &ip1;

Позднее назначение изменило значение ipp. Вот почему он все еще указывает на ip1.

Что вы делаете с *ipp, т. Е. С ip1, не меняет того факта, что ipp указывает на ip1.

Обратите внимание на назначение:

ipp = &ip1;

результатов ipp, чтобы указать на ip1.

, поэтому для ipp, чтобы указать на ip2, мы должны изменить аналогичным образом

ipp = &ip2;

, чего мы явно не делаем. Вместо этого мы меняем значение по адресу, указанному в ipp. Выполняя следующее

*ipp = ip2;

, мы просто заменяем значение, сохраненное в ip1.

ipp = &ip1 означает *ipp = ip1 = &i, Now, *ipp = ip2 = &j. Таким образом, *ipp = ip2 по существу такой же, как ip1 = ip2.

Как и большинство новичков в теге C, на этот вопрос можно ответить, вернувшись к первым принципам:

• Указатель - это своего рода значение.
• A переменная содержит значение.
• Оператор & превращает переменную в указатель.
• Оператор * превращает указатель в переменную.

(Технически я должен сказать «lvalue» вместо «variable», но я считаю более понятным описать изменяемые места хранения как «переменные».)

Итак, у нас есть переменные:

int i = 5, j = 6;
int *ip1 = &i, *ip2 = &j;

Переменная ip1 содержит указатель . Оператор & превращает i в указатель, и этому значению указателя присваивается значение ip1. Таким образом, ip1 содержит указатель на i.

Переменная ip2 содержит указатель . Оператор & превращает j в указатель, а указатель присваивается ip2. Поэтому ip2 содержит указатель на j.

int **ipp = &ip1;

Переменная ipp содержит указатель. Оператор & превращает переменную ip1 в указатель и значение указателя присваивается ipp. Таким образом, ipp содержит указатель на ip1.

Подведем итог истории:

• i содержит 5
• j содержит 6
• ip1 содержит «указатель на i»
• ip2 содержит «указатель на j»
• ipp содержит «указатель на ip1»

Теперь мы говорим

*ipp = ip2;

Оператор * возвращает указатель обратно в переменную. Мы получаем значение ipp, которое является «указателем на ip1 и превращает его в переменную. Какую переменную? ip1, конечно!

Поэтому это просто еще один способ сказать

ip1 = ip2;

Итак, мы получаем значение ip2 .Какой это? "указатель на j". Мы присваиваем этому указателю значение ip1, поэтому ip1 теперь «указатель на j "

Мы только изменили одно: значение ip1:

• i содержит 5
• j содержит 6
• ip1 содержит «указатель на j»
• ip2 содержит «указатель на j»
• ipp содержит «указатель на ip1 "

Почему ipp все еще указывает на ip1, а не ip2?

Изменяется переменная, когда вы назначаете ему. Подсчитайте назначения: переменные не могут быть больше, чем есть назначения! Вы начинаете с назначения i, j, ip1, ip2 и ipp. Затем вы назначаете *ipp, который, как мы видели, означает то же самое, что «присваивать ip1». Поскольку вы не назначали ipp во второй раз, это не изменилось!

Если вы хотите изменить ipp, вам действительно нужно назначить ipp:

ipp = &ip2;

например.

Потому что, когда вы говорите

*ipp = ip2

, вы говорите, что объект, на который указывает ipp ', указывает направление памяти, которое указывает ip2.

Вы не говорите ipp, чтобы указать ip2.

ipp может содержать значение (например, to) указателя для объекта типа указателя . Когда вы выполняете

ipp = &ip2;  

, тогда ipp содержит адрес переменной (указатель) ip2, которая является (&ip2) указателя типа указателю , Теперь стрелка ipp во втором pic укажет на ip2.

Wiki говорит: Оператор * является оператором разыменования, который работает с переменной указателя и возвращает значение l-значение (переменная), эквивалентное значение по адресу указателя. Это называется разыменование указателя.

Применяя оператор * к ipp, отмените его до l-значения указателя к типу int . Разделяемое l-значение *ipp имеет указатель типа на int , оно может содержать адрес данных типа int. После утверждения

ipp = &ip1;

ipp адрес ip1 и *ipp удерживает адрес (указывающий) i. Вы можете сказать, что *ipp является псевдонимом ip1. И **ipp, и *ip1 являются псевдонимами для i. Выполняя

 *ipp = ip2;  

*ipp и ip2, обе точки в одном и том же месте, но ipp все еще указывают на ip1.

В действительности *ipp = ip2; копирует содержимое ip2 (адрес j) в ip1 (поскольку *ipp является псевдонимом для ip1), в что оба указателя ip1 и ip2 указывают на один и тот же объект (j). Итак, во втором рисунке стрелка ip1 и ip2 указывает на j, а ipp все еще указывает на ip1, поскольку никакая модификация не выполняется для изменения значения ipp.

надеюсь, что эта часть кода может помочь.

#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
    int i = 5, j = 6, k = 7;
    int *ip1 = &i, *ip2 = &j;
    int** ipp = &ip1;
    printf("address of value i: %p\n", &i);
    printf("address of value j: %p\n", &j);
    printf("value ip1: %p\n", ip1);
    printf("value ip2: %p\n", ip2);
    printf("value ipp: %p\n", ipp);
    printf("address value of ipp: %p\n", *ipp);
    printf("value of address value of ipp: %d\n", **ipp);
    *ipp = ip2;
    printf("value ipp: %p\n", ipp);
    printf("address value of ipp: %p\n", *ipp);
    printf("value of address value of ipp: %d\n", **ipp);
}

выводит:

[/g0]

Если вы добавите оператор указателя * к указателю, вы перенаправляете его с указателя на объект, на который указывает.

Примеры:

int i = 0;
int *p = &i; // <-- N.B. the pointer declaration also uses the `*`
             //     it's not the dereference operator in this context
*p;          // <-- this expression uses the pointed-to object, that is `i`
p;           // <-- this expression uses the pointer object itself, that is `p`

Поэтому:

*ipp = ip2; // <-- you change the pointer `ipp` points to, not `ipp` itself
            //     therefore, `ipp` still points to `ip1` afterwards.

*ipp = ip2; подразумевает:

Присвоить ip2 переменной, на которую указывает ipp. Это эквивалентно:

ip1 = ip2;

Если вы хотите сохранить адрес ip2 в ipp, просто выполните:

ipp = &ip2;

Теперь ipp указывает на ip2.

Объясните каждую переменную, представленную следующим образом:

type  : (name, adress, value)

, поэтому ваши переменные должны быть представлены следующим образом

int   : ( i ,  &i , 5 ); ( j ,  &j ,  6); ( k ,  &k , 5 )

int*  : (ip1, &ip1, &i); (ip1, &ip1, &j)

int** : (ipp, &ipp, &ip1)

Поскольку значение ipp равно &ip1, так inctruction:

*ipp = ip2;

изменяет значение на добавке &ip1 на значение ip2, что означает ip1:

(ip1, &ip1, &i) -> (ip1, &ip1, &j)

Но ipp еще:

(ipp, &ipp, &ip1)

Таким образом, значение ipp все еще &ip1, что означает, что оно все еще указывает на ip1.

Очень скоро вы установите

ipp = &ip1;

Теперь разыщите его как [, g1]

*ipp = *&ip1 // Here *& becomes 1  
*ipp = ip1   // Hence proved 

Мой вопрос: почему во втором изображении ipp все еще указывает на ip1, но не ip2?

вы разместили красивые картинки, я попытаюсь сделать Хорошее искусство ascii:

Как @ Robert-S-Barnes сказал в своем ответе: забыть о указателях , и что указывает на что, но думайте в терминах памяти. В принципе, int* означает, что он содержит адрес переменной, а int** содержит адрес переменной, который содержит адрес переменной. Затем вы можете использовать алгебру указателя для доступа к значениям или адресам: &foo означает address of foo, а *foo означает value of the address contained in foo.

Итак, поскольку указатели касаются памяти, лучший способ сделать это «осязаемым» - показать, что делает алгебра указателей в памяти.

Итак, вот ваша память вашей программы (упрощенная для примера):

name:    i   j ip1 ip2 ipp
addr:    0   1   2   3   4
mem : [   |   |   |   |   ]

, когда вы делаете свой исходный код:

int i = 5, j = 6;
int *ip1 = &i, *ip2 = &j;

Вот как выглядит ваша память:

name:    i   j ip1 ip2
addr:    0   1   2   3
mem : [  5|  6|  0|  1]

там вы видите ip1 и ip2 получает адреса i и j и ipp все еще не существуют. Не забывайте, что адреса - это просто целые числа, хранящиеся со специальным типом.

Затем вы объявляете и определяете ipp, например:

int **ipp = &ip1;

, поэтому вот ваша память:

name:    i   j ip1 ip2 ipp
addr:    0   1   2   3   4
mem : [  5|  6|  0|  1|  2]

, а затем вы меняете значение, указанное адресом, хранящимся в ipp, который является адресом, хранящимся в ip1:

*ipp = ip2;

памяти программы is

name:    i   j ip1 ip2 ipp
addr:    0   1   2   3   4
mem : [  5|  6|  1|  1|  2]

NB: поскольку int* является специальным типом, я предпочитаю всегда избегать объявления нескольких указателей в одной строке, так как я думаю, что нотация int *x; или int *x, *y; может вводить в заблуждение , Я предпочитаю писать int* x; int* y;

HTH

Поскольку вы изменили значение, на которое указывает ipp, а не значение ipp. Таким образом, ipp все еще указывает на ip1 (значение ipp), значение ip1 теперь совпадает с значением ip2, поэтому оба они указывают на j.

Это:

*ipp = ip2;

совпадает с:

ip1 = ip2;