Указатели
Концепты
Заголовок раздела «Концепты»- Адрес памяти
- Указатель
- Обозначение типа указателя
- Получение адреса переменной
- Вписывание по адресу и считывание по адресу, используя dereference (разыменовывание)
- Размер указателя vs размер того, на что он указывает
- Почемы указатели с разным размером элемента несовместимы
Примеры на понимание
Заголовок раздела «Примеры на понимание»Объясните, что произойдет в следующих отрезках кода. Также, запустите данный код, чтобы убедиться в правильности вашей логики.
Там, где
mainне был расписан, код помещается в типичный основной файл:#include <iostream>#include <cstdint>int main(){// сюда}
1. Адрес переменной
Заголовок раздела «1. Адрес переменной»int a{ 5 };int* b{ &a }; // int* b = &a;std::cout << b;std::cout << std::endl;Выполнение по шагам
Ответ:
int* b{ &a } сохраняет в b адрес переменной a.
Далее печатается адрес, сохраненный в b.
Не значение по адресу из b (записали бы как *b), а адрес в b.
Какой тип у переменной b?
Синтаксис определения переменных состоит из:
- типа;
- имеми переменной;
- необязательно, инициализации.
int* b{ &a }; — здесь:
int*— это тип;b— это имя переменной;{ &a }— это инициализация.
У b тип не int, а int*!
Какой тип у выражения &a?
& — это оператор, получающий адрес переменной.
& применяется не на значение a, а на саму переменную a.
Тип &a — это int*.
Этот тип хранит во время компиляции информацию о том,
что получаемый адрес является именно адресом переменной типа int,
а не какого-то другого типа.
&способен дать адрес любого объекта, но об этом в 13-й лабе.
2. Адрес неинициализированной переменной.
Заголовок раздела «2. Адрес неинициализированной переменной.»Допустимо ли подобное?
int a;int* b{ &a };std::cout << b;std::cout << std::endl;Выполнение по шагам
Ответ:
Можно брать адрес неинициализированной переменной. Напечатается как обычный адрес.
Недопустимо было бы считывать по этому адресу.
3. Оператор dereference (на запись)
Заголовок раздела «3. Оператор dereference (на запись)»int a { 1 };int* b{ &a };*b = 2;std::cout << a;std::cout << std::endl;Выполнение по шагам
Ответ:
В b был сохранен адрес переменной a.
На строчке *b = 2, *b позволяет сослатся на переменную,
находящуюся по адресу из b, то есть на a.
*b = 2 -> a = 2 вписывает 2 в a.
4. Число как адрес
Заголовок раздела «4. Число как адрес»Допустимо ли подобное?
int* b{ 32 };std::cout << *b;std::cout << std::endl;Ответ:
Нет. Адрес невозможно задать так напрямую, его необходимо получать используя
оператор & на что-то с чем связан адрес (например, переменную).
5. Оператор dereference (на чтение)
Заголовок раздела «5. Оператор dereference (на чтение)»int a{ 5 };int b{ *(&a) };std::cout << b;std::cout << std::endl;Правильный ответ:
Вычисление выражения *(&a):
&aпереходит в адрес переменнойa(скажем, 32).*32переходит по адресу, позволяя обращатся к переменнойa.- ссылка на
aв качестве выражения дает значение переменнойa, 5.
*(&a) -> *32 -> a -> 5
6. Пробелы в объявлениях указателей
Заголовок раздела «6. Пробелы в объявлениях указателей»int value{ 5 };int* a{ &value };int *b{ &value };int * c{ &value };int * d{ &value }; * a = 6;std::cout << *b << std::endl;std::cout << *c << std::endl;std::cout << * d << std::endl;Ответ
Трижды печатает 6.
int* a, int *b, int * c и int * d объявляют указатели типа int*.
Пробелы между этими токенами не меняют смысл объявления.
Все четыре указателя хранят адрес одной переменной.
Пробелы вокруг оператора разыменования тоже ничего не меняют: *a и * a обращаются к одной переменной.
7. Печать сложного выражения
Заголовок раздела «7. Печать сложного выражения»int a{ 5 };int* b{ &a };std::cout << (*b) + 7;std::cout << std::endl;Выполнение по шагам
Правильный ответ:
(*b) + 7 это выражение. Вычисляется по частям:
(*b)означает переход по адресу изbи восприятие этого как переменнойa.(*b) + 7->a + 7-aзаменяется на значение изa, потому что используется в качестве выражения.5 + 7->12.
8. Указатель на больший тип данных
Заголовок раздела «8. Указатель на больший тип данных»uint8_t a{ 5 };int* b{ &a };Выполнение по шагам
Правильный ответ:
Ошибка компиляции (см. видео про указатели)
9. Указатель на меньший тип данных
Заголовок раздела «9. Указатель на меньший тип данных»int a = 5;uint8_t* b = &a;Выполнение по шагам
Правильный ответ:
Ошибка компиляции (см. видео про указатели)
10. Зависимость адреса от значения
Заголовок раздела «10. Зависимость адреса от значения»Будет ли в b и в c тот же адрес?
int a = 5;int* b = &a;a = 6;int* c = &a;Выполнение по шагам
Правильный ответ:
Будет тот же адрес.
Переменные никогда не меняют свой адрес.
a = 6 впишет 6 в уже имеющуюся ячейку памяти.
Это не перенаправляет a в другую ячейку.
&a берет адрес ячейки a, а не значения в ней.
Он всегда будет давать тот же адрес, вне зависимости от того,
какое значение сохранили в a.
11. Это та же память!
Заголовок раздела «11. Это та же память!»int a = 5;int* ap = &a;
*ap = 6;std::cout << a;std::cout << std::endl;
a = 7;std::cout << *ap;std::cout << std::endl;Выполнение по шагам
Ответ:
Запись и чтение всегда происходит по тому же адресу.
ap содержит адрес переменной a.
Запись в или чтение из *ap эквивалентно работе с a напрямую.
12. Инициализация через указатель
Заголовок раздела «12. Инициализация через указатель»Допустимо ли подобное?
int a;int* b = &a;*b = 5;std::cout << a;std::cout << std::endl;Выполнение по шагам
Ответ:
Переменную можно инициализировать через указатель. Подобное допустимо.
13. Перезапись указателя
Заголовок раздела «13. Перезапись указателя»int a = 5;
int* p = &a;*p = 6;
int b = 7;
p = &b;*p = 8;
std::cout << a;std::cout << std::endl;
std::cout << b;std::cout << std::endl;Выполнение по шагам
Ответ:
На строчке p = &b перезаписывается сам адрес из p на адрес другой переменной (b).
*p = 8 впишет 8 уже в b.
14. Двойной указатель
Заголовок раздела «14. Двойной указатель»int a = 5;int b = 6;int* p = &a;int** pp = &p;**pp = 7;
*pp = &b;**pp = 8;
std::cout << a;std::cout << std::endl;
std::cout << b;std::cout << std::endl;Выполнение по шагам
Ответ
int a = 5; // скажем, адрес = 32int b = 6; // скажем, адрес = 36int* p = &a; // адрес p = 40, адрес в p = 32int** pp = &p; // адрес в pp = 40**pp = 7; // *(*pp) --> *(40) --> *(p) --> *32 --> a // то есть a = 7*pp = &b; // адрес в p = 36**pp = 8; // *(*pp) --> *(40) --> *(p) --> *36 --> b // то есть b = 8
std::cout << a;std::cout << std::endl;
std::cout << b;std::cout << std::endl;15. auto из адреса
Заголовок раздела «15. auto из адреса»int value{ 5 };auto p{ &value };*p = 8;std::cout << value << std::endl;Выполнение по шагам
Ответ
У &value тип int*, поэтому у p тоже тип int*.
Печатает 8: запись через указатель с выведенным типом изменяет value.
16. auto из указателя и его значения
Заголовок раздела «16. auto из указателя и его значения»int value{ 5 };int* p{ &value };auto copiedPointer{ p };auto copiedValue{ *p };*copiedPointer = 8;std::cout << value << std::endl;std::cout << copiedValue << std::endl;Выполнение по шагам
Ответ
У p тип int*, а у *p — int.
Поэтому copiedPointer указывает на ту же переменную, а copiedValue — отдельная копия целого числа.
Печатает 8 и 5.
17. auto из адреса указателя
Заголовок раздела «17. auto из адреса указателя»int value{ 5 };int* p{ &value };auto pp{ &p };**pp = 9;std::cout << value << std::endl;Выполнение по шагам
Ответ
У &p тип int**, поэтому у pp тип int**.
*pp обращается к p, а **pp — к value.
Печатает 9.
18. Размеры указателей
Заголовок раздела «18. Размеры указателей»int a = 7;int* pa = &a;void* voidp = pa;
uint8_t c = 9;uint8_t* pc = &c;
std::cout << sizeof(pa);std::cout << std::endl;
std::cout << sizeof(voidp);std::cout << std::endl;
std::cout << sizeof(pc);std::cout << std::endl;Ответ
Размер указателя любого типа тот же, потому что это лишь адрес памяти.
На 64-битных системах размер любого указателя 64 бита (скорее всего вы на 64-битной).
19. Размер указателя и переменной
Заголовок раздела «19. Размер указателя и переменной»int a = 7;int* ap = &a;
std::cout << sizeof(a);std::cout << std::endl;
std::cout << sizeof(ap);std::cout << std::endl;
std::cout << sizeof(*ap);std::cout << std::endl;Ответ
sizeof(a) это то же, что и sizeof(int), 4.
sizeof(ap) это то же, что и sizeof(int*), 8.
sizeof(*ap) не вычисляет выражение *ap, а лишь смотрит, какой тип у результата был бы.
Чтение из *ap дало бы int, поэтому считается sizeof(int), 4.
20. Указатель на самого себя
Заголовок раздела «20. Указатель на самого себя»void* p = nullptr;p = static_cast<void*>(&p);
std::cout << p;std::cout << std::endl;
std::cout << &p;std::cout << std::endl;Ответ
&p берет адрес самой переменной p.
Тип выражения &p — это void** (адрес переменной типа void*).
static_cast<void*>(...) явно преобразует этот void** в void*,
то есть в тип самой переменной p.
Поэтому присваивание p = static_cast<void*>(&p) сохраняет
в p адрес самой p — теперь p указывает на саму себя.
Напечатаются два одинаковых адреса: значение в p и адрес &p совпадают.
Если static_cast<void*> тут опустить, он все равно произойдет сам по себе
21. Пустая инициализация указателя
Заголовок раздела «21. Пустая инициализация указателя»int* p{};std::cout << p << std::endl;Выполнение по шагам
Ответ
Пустые фигурные скобки означают, что указатель инициализируется значением по умолчанию.
Для указателей это значение — nullptr.
Это то же самое, что написать int* p{ nullptr };.
Поэтому напечатается 0 (нулевой адрес).
Это отличается от int* p;: там p остаётся неинициализированным, и в нём лежат мусорные данные.
В отличие от неинициализированного указателя, читать сам p здесь можно (например, печатать его).
Само разыменовывание p всё равно недопустимо, так как он ни на что не указывает.
22. Копирование переменной и указателя с похожими именами
Заголовок раздела «22. Копирование переменной и указателя с похожими именами»int x{ 0 };int* px{ &x };int y{ x };int* py{ px };
*px = 1;
std::cout << x << std::endl;std::cout << y << std::endl;std::cout << *px << std::endl;std::cout << *py << std::endl;Выполнение по шагам
Ответ:
int y{ x } копирует значение из x — дальше y независима от x,
поэтому запись через указатель ее не меняет.
int* py{ px } копирует адрес из px — оба указателя смотрят на одну и ту же переменную x.
*px = 1 вписывает 1 в x, поэтому напечатается:
x—1,y—0(значение скопировано до записи),*px—1,*py—1(указывает туда же, куда иpx).
Задания на проверку типов
Заголовок раздела «Задания на проверку типов»Каждый фрагмент независим. Компилируется ли он? Назовите типы обеих сторон последнего присваивания. Большинство фрагментов намеренно неверны; объясните исправление вместо попытки их выполнить.
1. Целое число присваивается указателю
Заголовок раздела «1. Целое число присваивается указателю»int value{ 5 };int* p{};p = value;Выполнение по шагам
Ответ
Не компилируется.
Справа тип int, а слева требуется int*.
Чтобы сохранить адрес, используйте p = &value;.
2. Указатель присваивается двойному указателю
Заголовок раздела «2. Указатель присваивается двойному указателю»int value{ 5 };int* p{ &value };int** pp{};pp = p;Выполнение по шагам
Ответ
Не компилируется.
У p тип int*, а для pp требуется int**.
Используйте pp = &p;, чтобы указать на переменную-указатель.
3. Указатель присваивается целому числу
Заголовок раздела «3. Указатель присваивается целому числу»int value{ 5 };int* p{ &value };int result{};result = p;Выполнение по шагам
Ответ
Не компилируется.
p — адрес типа int*, а не целочисленное значение.
Используйте result = *p;, чтобы скопировать значение по указателю.
4. Адрес указателя присваивается указателю
Заголовок раздела «4. Адрес указателя присваивается указателю»int value{ 5 };int* p{ &value };int* other{};other = &p;Выполнение по шагам
Ответ
Не компилируется.
У &p тип int**, а у other — int*.
Используйте other = p;, чтобы скопировать сохранённый адрес, либо объявите other как int** для хранения &p.
5. Адрес целого числа присваивается двойному указателю
Заголовок раздела «5. Адрес целого числа присваивается двойному указателю»int value{ 5 };int** pp{};pp = &value;Выполнение по шагам
Ответ
Не компилируется.
У &value тип int*, а не int**.
Дополнительная * в объявлении не означает, что переменная принимает любой адрес.
6. Копирование указателя через двойной указатель
Заголовок раздела «6. Копирование указателя через двойной указатель»int value{ 5 };int* p{ &value };int** pp{ &p };int* other{};other = *pp;Выполнение по шагам
Ответ
Компилируется.
У *pp тип int*, поэтому присваивание допустимо.
Теперь other и p указывают на одно целое число.
7. Одно разыменование вместо двух
Заголовок раздела «7. Одно разыменование вместо двух»int value{ 5 };int* p{ &value };int** pp{ &p };int result{};result = *pp;Выполнение по шагам
Ответ
Не компилируется.
У *pp тип int*, а для result нужен int.
Используйте result = **pp;, чтобы прочитать целое число.
8. Запись через два разыменования
Заголовок раздела «8. Запись через два разыменования»int value{ 5 };int* p{ &value };int** pp{ &p };**pp = 8;Выполнение по шагам
Ответ
Компилируется.
**pp обращается к переменной value типа int.
Присваивание допустимо и записывает в неё 8.
9. Адрес size_t присваивается указателю на int8_t
Заголовок раздела «9. Адрес size_t присваивается указателю на int8_t»#include <cstddef>#include <cstdint>size_t count{ 3 };int8_t* p{};p = &count;Выполнение по шагам
Ответ
Не компилируется.
У &count тип size_t*, а не int8_t*.
Указатели сохраняют тип переменной; это присваивание не выполняет числовое преобразование.
10. Адрес int8_t присваивается указателю на size_t
Заголовок раздела «10. Адрес int8_t присваивается указателю на size_t»#include <cstddef>#include <cstdint>int8_t value{ 3 };size_t* p{};p = &value;Выполнение по шагам
Ответ
Не компилируется.
У &value тип int8_t*, а для p требуется size_t*.
Даже если число помещается в обоих типах, их указатели не становятся совместимыми.
11. Значение int8_t присваивается size_t
Заголовок раздела «11. Значение int8_t присваивается size_t»#include <cstddef>#include <cstdint>int8_t value{ 3 };size_t count{};count = value;Выполнение по шагам
Ответ
Компилируется.
Это числовое присваивание, поэтому значение преобразуется в size_t.
В count записывается 3.
Адрес не присваивается и не переинтерпретируется.
12. Значение size_t присваивается указателю
Заголовок раздела «12. Значение size_t присваивается указателю»#include <cstddef>size_t count{ 3 };size_t* p{};p = count;Выполнение по шагам
Ответ
Не компилируется.
У count тип size_t, а для p требуется size_t*.
Размер числового типа не превращает его значения в указатели.
13. Двойной указатель с другим типом данных
Заголовок раздела «13. Двойной указатель с другим типом данных»#include <cstddef>#include <cstdint>size_t count{ 3 };size_t* p{ &count };int8_t** pp{};pp = &p;Выполнение по шагам
Ответ
Не компилируется.
У &p тип size_t**, а для pp требуется int8_t**.
Совпадения числа звёздочек недостаточно: типы данных тоже должны совпадать.
14. Адрес size_t с неверным числом уровней указателя
Заголовок раздела «14. Адрес size_t с неверным числом уровней указателя»#include <cstddef>size_t count{ 3 };size_t** pp{};pp = &count;Выполнение по шагам
Ответ
Не компилируется.
У &count тип size_t*, а не size_t**.
Сначала создайте указатель на count, затем возьмите адрес этого указателя.
15. Присваивание size_t значения int8_t, прочитанного через указатель
Заголовок раздела «15. Присваивание size_t значения int8_t, прочитанного через указатель»#include <cstddef>#include <cstdint>int8_t small{ 3 };int8_t* p{ &small };size_t count{};count = *p;Выполнение по шагам
Ответ
Компилируется.
У *p тип int8_t, поэтому числовое значение преобразуется в size_t.
В count записывается 3; сам указатель не присваивается.