Указатели в c++, вопросы новичка

[Enchance]

Здравствуйте.

Изучаю с++, хочу понять принцип работы указателей.

Пишу вот такой код:

#include <iostream>
using namespace std;
int main()
{
    //part1:
    int n, *p;
    cout << "\n==========================\n";
    cout << "p = " << p << "\n";
    cout << "*p = " << *p << "\n";
    cout << "&p = " << &p << "\n";

    //part2:
    p = &n;
    cout << "\n==========================\n";
    cout << "p = " << p << "\n";
    cout << "*p = " << *p << "\n";
    cout << "&p = " << &p << "\n";

    //part3:
    *p = 5;
    cout << "\n==========================\n";
    cout << "p = " << p << "\n";
    cout << "*p = " << *p << "\n";
    cout << "&p = " << &p << "\n";
}

Получаю на выходе:

==========================
p = 0x6c8ff4
*p = 1428860
&p = 0xbf95fc78

==========================
p = 0xbf95fc7c
*p = -1080689512
&p = 0xbf95fc78

==========================
p = 0xbf95fc7c
*p = 5
&p = 0xbf95fc78

А теперь ломаю голову, почему так. В частности, интересно вот что:
1. &p возвращает адрес, *p возвращает значение того, что находится по адресу, а что тогда возвращает p?
2. Почему значения &p и p в первом случае разные, а во втором отличаются на 4?
3. Почему во втором случае *p изменило свое значение?
4. Где хранится переменная *p, как взять ее адрес?

Сорри за глупые вопросы, я нигде не могу найти литературы, которая доступно все это обьясняет.

[Blade]

p - это адрес ячейки, в котором находится значение
*p - это само значение
&p - адрес ячейки, в которой находится указатель

Значения &p во всех случаях одинаковые, т.к. ячейка под адрес указателя выделяется в момент его объявления, и дальше не меняется.

В момент объявления указателя он указывает на произвольное место в памяти, поэтому в первом случаи значение p произвольно. Потом вы присвоили указателю p адрес ячейки, в которой хранится значение переменной n, поэтому во втором и третьем случаи p имеет такое значение

Далее вы изменили значение, на которое указывает p, но адрес его не изменился

[Сыроежка]

Сообщение от Enchance

Здравствуйте.

Изучаю с++, хочу понять принцип работы указателей.

Пишу вот такой код:

#include <iostream>
using namespace std;
int main()
{
    //part1:
    int n, *p;
    cout << "\n==========================\n";
    cout << "p = " << p << "\n";
    cout << "*p = " << *p << "\n";
    cout << "&p = " << &p << "\n";

    //part2:
    p = &n;
    cout << "\n==========================\n";
    cout << "p = " << p << "\n";
    cout << "*p = " << *p << "\n";
    cout << "&p = " << &p << "\n";

    //part3:
    *p = 5;
    cout << "\n==========================\n";
    cout << "p = " << p << "\n";
    cout << "*p = " << *p << "\n";
    cout << "&p = " << &p << "\n";
}

Получаю на выходе:



А теперь ломаю голову, почему так. В частности, интересно вот что:
1. &p возвращает адрес, *p возвращает значение того, что находится по адресу, а что тогда возвращает p?
2. Почему значения &p и p в первом случае разные, а во втором отличаются на 4?
3. Почему во втором случае *p изменило свое значение?
4. Где хранится переменная *p, как взять ее адрес?

Сорри за глупые вопросы, я нигде не могу найти литературы, которая доступно все это обьясняет.

Отвечаю на все ваши вопросы!

P = это локальная переменная. Поэтому если вы ее не инициализировали, то она может хранить любое произвольное значение, которое случайно оказалось в том месте, которое было выделено для этого указателя.
Поэтому когда вы первый раз делали вывод

cout << "p = " << p << "\n";

то было выведено некоторое случайное число, то есть "мусор". Дале по адресу этого "мусора", вы пытаетесь вывести то, что там хранится. Опять-таки выводится случайное число, которое находится по этому случайному мусору.

cout << "*p = " << *p << "\n";

Далее вы выводите адрес самого указателя. Это единственные корректные данные, которые во всех трех случаях должны у вас совпадать, так как адрес самого указателя не меняется. И оно так и есть, как видно из полученных данных.

Далее вы указателю p присваиваете адрес целочисленной переменной n, которая в свою очередь у вас не инициализирована. Но теперь у вас указатель p хранит корректное значение адреса переменной n, а потому в последних двух блоках вывода этот адрес должен совпадать. Однако, когда вы выводите

cout << "*p = " << *p << "\n";

то у вас выводится "мусор", так как ваша переменная n не была инициализирована, и в ней хранится случайное значение. То есть при объявлении локальных переменных, если вы сами не указываете для них значение, то они будут содержать тот мусор, который был в памяти.

Затем вы по адресу, который хранится в указателе, присваиваете некоторое значение

*p = 5;

Вы тем самым переменной n присваиваете значение, так как указатель p на этот раз указывает на переменную n.

Итак, подведем итоги. &p - возвращает адрес самой переменной p. p - возвращает адрес переменной n, после того, как вы его присвоили переменной p
p = &n;

а *p - это косвенное обращение к переменной n через адрес, хранящийся в указателе p. На остальные ваши вопросы я ответил выше, когда комментировал ваш код.

Нужно просто понимать, что p и n - это две отдельные переменные. Каждая из них имеет свой адрес. &p - это адрес переменной p, &n - это адрес переменной n. Адрес переменной n вы занесли в переменную p. У самой переменной p адрес не изменился! Изменилось лишь содержимое переменной p, а сама переменная p где была расположена в памяти, на том же самом месте и осталась.

У вас бы могла измениться картина, если бы вы переменную n объявили вне функции main. Такие переменные компилятором инициализируются значениями по умолчанию, которые для целочисленных типов равны 0. То есть тогда бы вас вывод изменился бы. Во втором блоке вывода после того, как вы указателю p присвоили адрес переменной n, у вас бы вывелся 0 врезультате предложения


cout << "*p = " << *p << "\n";

[Kulikcha]

Насчёт литературы. Можешь изучить книгу С++ базовый курс Герберта Шилдта. Очень доходчиво и для новичком. Всё про это есть там.

Или я могу попробовать объяснить.Пиши тогда

[jacek]

Вот еще в довесок интересненькая программка: в свое время очень помогла разобраться с указателями.

#include <iostream>
using namespace std;

int main()
{
    cout << "CHAR   size: " << sizeof(char);
    cout << "\nCHAR*  size: " << sizeof(char*);
    cout << "\nSHORT  size: " << sizeof(short);
    cout << "\nSHORT* size: " << sizeof(short*);
    cout << "\nINT    size: " << sizeof(int);
    cout << "\nINT*   size: " << sizeof(int*);

    cout << endl;
    return 0;
}

Результат на картинке. Можно заметить, что тип char имеет размер 1 байт, а вот char* имеет 4 байт, равно как и все остальные типы со звездочкой. Все потому, что адрес ячейки памяти занимает 4 байт. То есть, типы char и char* лучше воспринимать как разные типы данных. То есть, строку char *p лучше писать char* p. (Подробности по ссылке ниже)
Чтобы не писать еще раз, то что за меня прекрасно написали, вот статейка:
http://www.sofmos.com/lyosha/Article..._Asterisk.html

[Alex11223]

Все потому, что адрес ячейки памяти занимает 4 байт. То есть, строку char *p лучше писать char* p.

о_О и каким образом это связано? Почему лучше? А если char* p, p1?

[jacek]

Сообщение от Alex11223

о_О и каким образом это связано? Почему лучше? А если char* p, p1?

К тому, что надо нажать по ссылке на статью, где все хорошо расписано. Не хочу объяснять то, что и так прекрасно объяснено. ЛИЧНО МНЕ помогла именно эта статья, хотя тоже не въезжан поначалу в указатели.

[Пепел Феникса]

автор статьи видимо не способен отличить обьявление перемененной от разименовывания указателя раз дал такой совет.
звездочка атрибут переменной все-таки(при обьявлении)

хотя тут нет слова "Надо", есть слово "удобно". и это уже личное.

[Alex11223]

И что в статье? Тоже написано

int* a, b; // неправильно!

Какой тип имеет переменная b? Гладя на этот код можно подумать, что это указатель на целое число. Но это неправильно! Потому что с точки зрения компилятора звёздочка относится только к переменной a, поэтому она действительно является указателем. b же – просто переменнная типа int. Поэтому, чтобы избежать недоразумений мы должны прилепить звёздочку к имени переменной-указателя:

int *a, b; // (3)

Вы же наоборот говорите, что

типы char и char* лучше воспринимать как разные типы данных. То есть, строку char *p лучше писать char* p.

да еще и каким-то образом связываете это с 4 байтами, которые занимает указатель.

[jacek]

Сообщение от Пепел Феникса

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

на самом деле, когда я не понимал разницы между этими двумя операторами, статья очень помогла. Зато я не задавал в "стопитьсотый" раз вопрос на форуме: "зачем..., почему..., что такое указатели".