bulgakov

39. Указатели: адрес и стрелка

Указатель — это переменная, в которой хранится адрес другой переменной. С его помощью можно прийти к чужой переменной и прочитать или изменить её значение. Эта тема нужна, чтобы понять, как функции меняют внешние переменные и почему массив из сортировки меняется внутри функции: об этом следующая глава.

Что пригодится из прошлого: переменные, массивы, область видимости. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.

Память — улица с домиками

Представьте память как длинную улицу. Каждый байт — домик со своим номером. Этот номер называется адресом.

Значение занимает несколько домиков подряд. Переменная типа int занимает 4 байта, char — 1, double — 8 (в обычной среде; размеры можно проверить через sizeof, как в уроке про массивы). Адрес переменной — это номер её первого домика.

Значения переменных лежат в памяти, и у каждой есть место. Раньше мы видели только значения: x — это 10. Теперь научимся работать и с местом.

Два значка: & и *

Два знака отвечают за работу с адресами. У звёздочки два разных смысла, и они зависят от места записи.

Запись Где стоит Что означает
&x в выражении «адрес x»: где живёт переменная
int *p в объявлении «p — указатель на int»: коробка для адреса
*p в выражении «иди по стрелке»: прочитай или запиши то, что лежит по адресу

Полная программа:

C
#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

Разберём по строкам.

C
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 *:

C
#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.

Так же можно взглянуть на элементы массива из урока про массивы. Они лежат подряд:

C
#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). Важно лишь то, что соседи отличаются на размер элемента.

Подвохи

Указатели позволяют делать ошибки, которые трудно заметить.

Указатель без адреса. Рассмотрим:

C
int *p;
*p = 5;    /* опасно */

В новом p лежит случайное число. Запись *p = 5; отправляет пятёрку по непонятному адресу: программа портит чужие данные или аварийно завершается. Поэтому указатель сразу получает адрес или значение NULL. NULL означает «никуда не указывает»:

C
#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. Проверим размеры:

C
#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. Что напечатает программа? Сначала подумайте сами.

C
#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. А эта?

C
#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.
ПрактикаЗагружаем тест…