39. Указатели: адрес и стрелка
Указатель — это переменная, в которой хранится адрес другой переменной. С его помощью можно прийти к чужой переменной и прочитать или изменить её значение. Эта тема нужна, чтобы понять, как функции меняют внешние переменные и почему массив из сортировки меняется внутри функции: об этом следующая глава.
Что пригодится из прошлого: переменные, массивы, область видимости. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.
Память — улица с домиками
Представьте память как длинную улицу. Каждый байт — домик со своим номером. Этот номер называется адресом.
Значение занимает несколько домиков подряд. Переменная типа int занимает 4 байта, char — 1, double — 8 (в обычной среде; размеры можно проверить через sizeof, как в уроке про массивы). Адрес переменной — это номер её первого домика.
Значения переменных лежат в памяти, и у каждой есть место. Раньше мы видели только значения: x — это 10. Теперь научимся работать и с местом.
Два значка: & и *
Два знака отвечают за работу с адресами. У звёздочки два разных смысла, и они зависят от места записи.
| Запись | Где стоит | Что означает |
|---|---|---|
&x |
в выражении | «адрес x»: где живёт переменная |
int *p |
в объявлении | «p — указатель на int»: коробка для адреса |
*p |
в выражении | «иди по стрелке»: прочитай или запиши то, что лежит по адресу |
Полная программа:
#include <stdio.h>
int main(void)
{
int x = 10;
int y = 3;
int *p = &x;
printf("x = %d, *p = %d\n", x, *p);
*p = 25;
printf("x = %d\n", x);
p = &y;
*p = 7;
printf("x = %d, y = %d\n", x, y);
return 0;
}
Вывод:
x = 10, *p = 10
x = 25
x = 25, y = 7
Разберём по строкам.
int x = 10;
int y = 3;
int *p = &x;
p — указатель на int. Его начальное значение — адрес переменной x. Картинка:
p x
┌─────────┐ ┌─────────┐
│ &x │ ───► │ 10 │
└─────────┘ └─────────┘
А вот как то же самое лежит в памяти. Адреса здесь условные, настоящие — длинные шестнадцатеричные числа:
условный адрес: 1000 1004 1008
┌─────────┬─────────┬─────────┐
имя: │ x │ y │ p │
значение: │ 10 │ 3 │ 1000 │
└─────────┴─────────┴─────────┘
Указатель p — обычная переменная: в ней записано число, и это число 1000 — адрес, где лежит x. Стрелка — всего лишь удобный способ нарисовать, что число из p совпадает с адресом x.
*pв первой печати читает значение по стрелке. Там лежит10, как уx.*p = 25;записывает25по адресу, на который указываетp. Это местоx, поэтомуxстал25, хотя мы не писалиx = 25.p = &y;без звёздочки меняет саму стрелку. Теперьpуказывает наy. Значениеxне затрагивается.*p = 7;теперь записывает вy. Итог:x = 25,y = 7.
Итак: p = ... переставляет стрелку, *p = ... меняет то, на что она указывает.
Печать адреса
Адрес можно напечатать. Для этого в printf есть формат %p. Аргумент приводят к типу void *:
#include <stdio.h>
int main(void)
{
int x = 10;
int *p = &x;
printf("address of x: %p\n", (void *)&x);
printf("p holds: %p\n", (void *)p);
printf("p == &x: %d\n", p == &x);
return 0;
}
Пример вывода:
address of x: 0x16f75e500
p holds: 0x16f75e500
p == &x: 1
Конкретное число у вас будет другим: система может выбирать адреса по-разному при каждом запуске. Запись (void *) перед &x приводит адрес к «адресу без указания типа»: именно такой аргумент ждёт формат %p. Пока просто копируйте её. Важно, что первые две строки одинаковы: p хранит адрес x. Сравнение p == &x истинно и даёт 1.
Так же можно взглянуть на элементы массива из урока про массивы. Они лежат подряд:
#include <stdio.h>
int main(void)
{
int a[3] = {10, 20, 30};
for (int i = 0; i < 3; i++) {
printf("&a[%d] = %p\n", i, (void *)&a[i]);
}
return 0;
}
Пример вывода:
&a[0] = 0x16afa24a0
&a[1] = 0x16afa24a4
&a[2] = 0x16afa24a8
Адреса соседних элементов отличаются на 4, то есть на размер одного int в нашей среде. Адреса записаны в шестнадцатеричной системе: после цифр идут буквы a–f, обозначающие 10–15. Поэтому после …a8 следующий адрес был бы …ac (8 + 4 = 12, это c). Важно лишь то, что соседи отличаются на размер элемента.
Подвохи
Указатели позволяют делать ошибки, которые трудно заметить.
Указатель без адреса. Рассмотрим:
int *p;
*p = 5; /* опасно */
В новом p лежит случайное число. Запись *p = 5; отправляет пятёрку по непонятному адресу: программа портит чужие данные или аварийно завершается. Поэтому указатель сразу получает адрес или значение NULL. NULL означает «никуда не указывает»:
#include <stdio.h>
int main(void)
{
int x = 5;
int *p = NULL;
if (p == NULL) {
printf("p points nowhere yet\n");
}
p = &x;
if (p != NULL) {
*p = 10;
printf("x = %d\n", x);
}
return 0;
}
Вывод:
p points nowhere yet
x = 10
Читать или писать по NULL нельзя: поведение программы не определено, и обычно она аварийно завершается. Перед использованием проверяем if (p != NULL). NULL объявлен в <stdio.h>.
Звёздочка относится к имени. Запись int *a, b; объявляет a указателем, а b обычным int. Проверим размеры:
#include <stdio.h>
int main(void)
{
int *a, b;
printf("a is a pointer, its size: %zu\n", sizeof(a));
printf("b is an int, its size: %zu\n", sizeof(b));
return 0;
}
Вывод на 64-разрядной системе:
a is a pointer, its size: 8
b is an int, its size: 4
Указатель занимает 8 байт: это размер адреса в такой среде. Чтобы не ошибиться, пишите по одному объявлению на строку: int *a; и int b;.
Забыл звёздочку. Запись p = 10; вместо *p = 10; смешивает int и int *. Компилятор выдаёт диагностику: в зависимости от версии это предупреждение или ошибка. Игнорировать её нельзя. Запомните: & добавляет звёздочку к типу (int → int *), а * снимает (int * → int).
Проверка на минуту
Задача 1. Что напечатает программа? Сначала подумайте сами.
#include <stdio.h>
int main(void)
{
int a = 5, b = a;
int *p = &a;
*p = 7;
printf("a = %d, b = %d\n", a, b);
return 0;
}
Ответ к задаче 1
Вывод: a = 7, b = 5. Переменная b получила копию пятёрки до изменения. Указатель смотрит только на a, поэтому *p = 7 меняет a, а b остаётся 5.
Задача 2. А эта?
#include <stdio.h>
int main(void)
{
int n = 3;
int *p1 = &n;
int *p2 = &n;
*p1 += 5;
*p2 *= 2;
printf("n = %d\n", n);
return 0;
}
Ответ к задаче 2
Вывод: n = 16. Обе стрелки ведут в одну и ту же n. Сначала 3 + 5 = 8, затем 8 · 2 = 16.
Что запомнить
- Адрес — номер первого байта переменной.
&x— адресx;%pпечатает адрес. int *pобъявляет указатель.*pв выражении означает «значение по адресу».p = &y;переставляет стрелку,*p = 7;меняет то, на что она указывает.- Указатель сразу получает адрес или
NULL. ПоNULLходить нельзя. - В
int *a, b;указатель толькоa.
