Перейти к содержимому

Указатели

  • Адрес памяти
  • Указатель
  • Обозначение типа указателя
  • Получение адреса переменной
  • Вписывание по адресу и считывание по адресу, используя dereference (разыменовывание)
  • Размер указателя vs размер того, на что он указывает
  • Почемы указатели с разным размером элемента несовместимы

Объясните, что произойдет в следующих отрезках кода. Также, запустите данный код, чтобы убедиться в правильности вашей логики.

Там, где main не был расписан, код помещается в типичный основной файл:

#include <iostream>
#include <cstdint>
int main()
{
// сюда
}
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?

Синтаксис определения переменных состоит из:

  1. типа;
  2. имеми переменной;
  3. необязательно, инициализации.

int* b{ &a }; — здесь:

  1. int* — это тип;
  2. b — это имя переменной;
  3. { &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;
Выполнение по шагам
Ответ:

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

Недопустимо было бы считывать по этому адресу.

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.

Допустимо ли подобное?

int* b{ 32 };
std::cout << *b;
std::cout << std::endl;
Ответ:

Нет. Адрес невозможно задать так напрямую, его необходимо получать используя оператор & на что-то с чем связан адрес (например, переменную).

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

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 обращаются к одной переменной.

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.
uint8_t a{ 5 };
int* b{ &a };
Выполнение по шагам
Правильный ответ:

Ошибка компиляции (см. видео про указатели)

int a = 5;
uint8_t* b = &a;
Выполнение по шагам
Правильный ответ:

Ошибка компиляции (см. видео про указатели)

Будет ли в b и в c тот же адрес?

int a = 5;
int* b = &a;
a = 6;
int* c = &a;
Выполнение по шагам
Правильный ответ:

Будет тот же адрес.

Переменные никогда не меняют свой адрес. a = 6 впишет 6 в уже имеющуюся ячейку памяти. Это не перенаправляет a в другую ячейку.

&a берет адрес ячейки a, а не значения в ней. Он всегда будет давать тот же адрес, вне зависимости от того, какое значение сохранили в a.

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 напрямую.

Допустимо ли подобное?

int a;
int* b = &a;
*b = 5;
std::cout << a;
std::cout << std::endl;
Выполнение по шагам
Ответ:

Переменную можно инициализировать через указатель. Подобное допустимо.

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.

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; // скажем, адрес = 32
int b = 6; // скажем, адрес = 36
int* p = &a; // адрес p = 40, адрес в p = 32
int** 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;
int value{ 5 };
auto p{ &value };
*p = 8;
std::cout << value << std::endl;
Выполнение по шагам
Ответ

У &value тип int*, поэтому у p тоже тип int*. Печатает 8: запись через указатель с выведенным типом изменяет value.

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.

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.

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-битной).

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.

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*> тут опустить, он все равно произойдет сам по себе

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).

Каждый фрагмент независим. Компилируется ли он? Назовите типы обеих сторон последнего присваивания. Большинство фрагментов намеренно неверны; объясните исправление вместо попытки их выполнить.

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;, чтобы указать на переменную-указатель.

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 указывают на одно целое число.

int value{ 5 };
int* p{ &value };
int** pp{ &p };
int result{};
result = *pp;
Выполнение по шагам
Ответ

Не компилируется. У *pp тип int*, а для result нужен int. Используйте result = **pp;, чтобы прочитать целое число.

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*. Даже если число помещается в обоих типах, их указатели не становятся совместимыми.

#include <cstddef>
#include <cstdint>
int8_t value{ 3 };
size_t count{};
count = value;
Выполнение по шагам
Ответ

Компилируется. Это числовое присваивание, поэтому значение преобразуется в size_t. В count записывается 3. Адрес не присваивается и не переинтерпретируется.

#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; сам указатель не присваивается.