bulgakov

41. Указатель и массив: шаг, индекс и граница

Указатель на элемент массива можно сдвигать. Запись p + 1 даёт адрес следующего элемента, а не следующего байта. В этом уроке разберём, что именно хранит указатель и как он шагает по массиву. Затем найдём границу, за которую выходить нельзя, и посмотрим, почему массив всё-таки не указатель. Записи &x, *p, печать через %p и смысл NULL описаны в уроке про указатели. Передача массива в функцию разобрана в уроке про адреса и функции.

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

Указатель тоже лежит в памяти

Указатель является обычной переменной. Значит, у него есть своё место в памяти и свой адрес. Четыре записи легко перепутать:

Запись Что обозначает
&x адрес переменной x
p значение указателя: адрес, который в нём записан
*p объект по этому адресу, то есть сама x
&p адрес переменной p: место, где хранится сам указатель

Проверим программой. Адреса меняются от запуска к запуску, поэтому печатаем не сами числа, а результаты сравнений: 1 означает «адреса равны», 0 означает «разные».

C
#include <stdio.h>

int main(void)
{
    int x = 10;
    int *p = &x;

    printf("*p = %d\n", *p);
    printf("p == &x: %d\n", p == &x);
    printf("&p == &x: %d\n", (void *)&p == (void *)&x);
    return 0;
}

Вывод:

*p = 10
p == &x: 1
&p == &x: 0

Переменная p получила значение &x, поэтому p == &x истинно. Запись *p прошла по этому адресу и прочитала 10. А &p указывает на место, где лежит сам p. Это другая переменная, и её адрес не совпадает с адресом x. У записей &p и &x разные типы, поэтому перед сравнением обе приведены к void *, «адресу без типа».

      p  (лежит по адресу &p)        x  (лежит по адресу &x)
┌──────────────────┐           ┌──────────┐
│ значение: &x     │ ────────► │    10    │
└──────────────────┘           └──────────┘

Если хочется увидеть сами адреса, печатайте их форматом %p с приведением (void *), как в уроке про указатели. Числа при этом будут меняться между запусками.

Тип указателя и sizeof

Указатель объявляют с типом объекта, на который он смотрит: int *ip, double *dp, float *fp, char *cp. По типу разыменование *p узнаёт, сколько байтов прочитать и как их понимать: как целое, дробное число или символ. Поэтому адрес double нельзя положить в int *. Во фрагменте double d = 1.5; int *ip = &d; компилятор отметит несовместимые типы указателей, а с флагом -Werror сборка остановится.

Оператор sizeof можно применить и к указателю, и к объекту по нему. Это разные размеры:

  • sizeof(*p) даёт размер объекта, на который указывает p. Для double *dp это sizeof(double).
  • sizeof(p) даёт размер самой переменной-указателя.

Результат sizeof имеет тип size_t, его печатают форматом %zu.

C
#include <stdio.h>

int main(void)
{
    double d = 2.5;
    double *dp = &d;
    char c = 'A';
    char *cp = &c;

    printf("sizeof(*dp) == sizeof(double): %d\n", sizeof(*dp) == sizeof(double));
    printf("sizeof(*cp) = %zu\n", sizeof(*cp));
    printf("sizeof(dp) == sizeof(double *): %d\n", sizeof(dp) == sizeof(double *));
    printf("*dp = %.1f, *cp = %c\n", *dp, *cp);
    return 0;
}

Вывод:

sizeof(*dp) == sizeof(double): 1
sizeof(*cp) = 1
sizeof(dp) == sizeof(double *): 1
*dp = 2.5, *cp = A

Размер char по определению равен 1, поэтому вторая строка одинакова на любой системе. Размер указателя язык C не фиксирует. На распространённых 64-разрядных системах указатель занимает 8 байт, на 32-разрядных 4, но это свойство платформы, а не правило языка. Стандарт даже не обещает, что int * и char * одного размера. Если размер нужен, спрашивайте sizeof и не подставляйте число.

Указатель на начало массива

Запись p = a; кладёт в p адрес первого элемента: в выражении имя массива превращается в &a[0]. Тогда p + i является адресом элемента с индексом i, а *(p + i) самим этим элементом. Квадратные скобки устроены так же: a[i] по определению означает *(a + i).

C
#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    int *p = a;

    for (int i = 0; i < 5; i++) {
        printf("%d: %d %d %d\n", i, *(p + i), a[i], p + i == &a[i]);
    }
    return 0;
}

Вывод:

0: 10 10 1
1: 20 20 1
2: 30 30 1
3: 40 40 1
4: 50 50 1

В каждой строке стоят индекс, значение через указатель, значение через скобки и результат сравнения p + i == &a[i]. Оба способа ведут к одним и тем же элементам.

индекс:     0     1     2     3     4
          ┌─────┬─────┬─────┬─────┬─────┐
a:        │ 10  │ 20  │ 30  │ 40  │ 50  │
          └─────┴─────┴─────┴─────┴─────┘
            ▲     ▲                 ▲     ▲
            p    p+1               p+4   p+5 (позиция за массивом)

Шаг измеряется в элементах

Сложение с указателем считает элементы. Если p указывает на a[0], то p + 1 указывает на a[1], сколько бы байтов ни занимал элемент. В памяти адрес сдвигается на i * sizeof(*p) байтов, но эта формула только объясняет происходящее. В программе её не пишут: компилятор умножает на размер сам. Запись p + i * sizeof(int) сдвинет указатель на i * sizeof(int) элементов. При 4-байтовом int вместо a[1] получится a[4], а при i = 2 указатель уйдёт за массив.

Запись Что получается Меняется ли p
p + i адрес на i элементов дальше нет
p - i адрес на i элементов раньше нет
p++, ++p p переходит к следующему элементу да
p--, --p p переходит к предыдущему элементу да
p += i p сдвигается на i элементов вперёд да
p -= i p сдвигается на i элементов назад да

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

C
#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    int *p = a;
    int *p1 = p;
    int *p2 = p;
    int *p3;

    p1++;
    p2 += 4;
    p3 = p2;
    p3 -= 1;

    printf("*p1 = %d\n", *p1);
    printf("*p2 = %d\n", *p2);
    printf("*p3 = %d\n", *p3);
    printf("*(p2 - 2) = %d\n", *(p2 - 2));
    printf("p1 < p2: %d\n", p1 < p2);
    printf("p1 >= p3: %d\n", p1 >= p3);
    return 0;
}

Вывод:

*p1 = 20
*p2 = 50
*p3 = 40
*(p2 - 2) = 30
p1 < p2: 1
p1 >= p3: 0

p1++ перевёл p1 с a[0] на a[1]. p2 += 4 перевёл p2 на a[4]. p3 -= 1 сдвинул копию p2 на a[3]. Выражение p2 - 2 сам p2 не меняет, оно только вычисляет адрес a[2]. Сравнения говорят о порядке в массиве: a[1] стоит раньше a[4], поэтому p1 < p2 даёт 1. a[1] стоит раньше a[3], поэтому p1 >= p3 даёт 0.

Сдвигать указатель имеет смысл только внутри массива. Одиночная переменная int x; для этих правил считается массивом из одного элемента: допустимы только &x и &x + 1. Записи &x + 4 и &x - 1 дают неопределённое поведение. Так называют ситуацию, для которой язык не говорит, что произойдёт: программа может напечатать что угодно, упасть или работать до случайного момента.

Граница массива

Для int a[5] допустимы указатели от a до a + 5. Последний из них, a + 5, обозначает позицию сразу за последним элементом. Его можно вычислить, сравнить с указателем того же массива и вычесть, но нельзя разыменовать: элемента там нет.

Указатель Вычислить Сравнить и вычесть Разыменовать
a … a + 4 да да да
a + 5 да да нет
a - 1, a + 6 нет нет нет

Записи a - 1 и a + 6 ошибочны, даже если по ним ничего не читать. Уже само вычисление даёт неопределённое поведение.

Позиция за массивом удобна, чтобы обозначить конец. Цикл идёт от начала, пока указатель не станет равен концу:

C
#include <stdio.h>

int main(void)
{
    int a[5] = {3, 1, 4, 1, 5};
    int *end = a + 5;
    int sum = 0;

    for (int *p = a; p != end; p++) {
        sum += *p;
    }
    printf("sum = %d\n", sum);
    return 0;
}

Вывод:

sum = 14

Указатель p проходит a, a + 1, …, a + 4 и читает каждый элемент. После пятого шага p становится равен end, условие p != end ложно, и цикл останавливается. Значение *end ни разу не читается. С условием p <= end последняя итерация прочитала бы *(a + 5), то есть вышла бы за границу.

Вычитание и сравнение

Разность двух указателей одного массива равна количеству элементов между ними. Её тип ptrdiff_t объявлен в <stddef.h>, печатают его форматом %td.

C
#include <stdio.h>
#include <stddef.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    int *first = &a[1];
    int *last = &a[4];
    int *end = a + 5;
    ptrdiff_t gap = last - first;

    printf("last - first = %td\n", gap);
    printf("end - a = %td\n", end - a);
    printf("first < last: %d\n", first < last);
    printf("last <= end: %d\n", last <= end);
    return 0;
}

Вывод:

last - first = 3
end - a = 5
first < last: 1
last <= end: 1

От a[1] до a[4] три шага, поэтому разность равна 3, а не числу байтов. end - a даёт длину массива, 5.

Сравнения <, <=, >, >= отвечают на вопрос «раньше или позже в массиве». В задачах этого урока применяйте их к указателям в один и тот же массив, включая позицию за ним. Сравнения == и != проверяют другое: совпадает ли адрес. Их можно применять и к указателям на разные объекты, ответ будет 0 или 1, но о порядке он ничего не скажет.

Если p и q указывают в разные массивы, то p < q и q - p дают неопределённое поведение. Одна проверка p >= a && p < a + 5 не является переносимым способом проверить произвольный чужой указатель: сам порядок адресов разных массивов так сравнивать нельзя. Поэтому границу держит сама программа: хранит длину или указатель на конец и не выходит за них.

Массив не является указателем

Имя массива в большинстве выражений превращается в адрес первого элемента. Но сам массив состоит из пяти int, лежащих подряд, а указатель хранит один адрес. Разница видна в двух исключениях: в sizeof и в &.

C
#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    int *p = a;

    printf("sizeof(a) == 5 * sizeof(int): %d\n", sizeof(a) == 5 * sizeof(int));
    printf("sizeof(a) / sizeof(a[0]) = %zu\n", sizeof(a) / sizeof(a[0]));
    printf("sizeof(p) == sizeof(int *): %d\n", sizeof(p) == sizeof(int *));
    printf("(void *)&a == (void *)a: %d\n", (void *)&a == (void *)a);
    return 0;
}

Вывод:

sizeof(a) == 5 * sizeof(int): 1
sizeof(a) / sizeof(a[0]) = 5
sizeof(p) == sizeof(int *): 1
(void *)&a == (void *)a: 1

sizeof(a) измеряет весь массив, поэтому деление на размер одного элемента даёт длину 5. sizeof(p) даёт размер одного указателя. &a обозначает адрес всего массива как единого целого. Он начинается там же, где a[0], но имеет другой тип, поэтому для сравнения оба адреса приведены к void *.

Указатель можно переставлять: p = a + 2;, p++. Имя массива переставить нельзя, фрагменты a = p; и a++ не компилируются. В параметре функции запись int arr[] означает указатель, как показано в уроке про адреса и функции. Поэтому внутри функции sizeof(arr) даёт размер указателя, и длину массива передают отдельным параметром.

NULL и арифметика

Из урока про указатели известно, что по NULL нельзя читать и писать. Сдвигать его тоже нельзя. NULL не указывает ни в какой массив, поэтому p + 1 или p++ при p == NULL дают неопределённое поведение, как и *p.

Проверка p != NULL говорит только, что указатель не нулевой. Она не доказывает, что объект ещё существует, и не сообщает, сколько элементов можно пройти. Время жизни объекта означает период, пока он существует в памяти. У переменной внутри блока оно заканчивается вместе с блоком (область видимости). Фрагмент только для иллюстрации, запускать его не нужно:

C
int *p = NULL;
{
    int t = 5;
    p = &t;
}
/* время жизни t закончилось: значение p стало неопределённым */

После окончания жизни t нельзя даже вычислять p != NULL: значение такого указателя стало неопределённым. До нового использования переменной p ей нужно присвоить допустимый адрес или NULL. Проверку на NULL выполняют, когда у указателя уже есть корректно заданное значение.

Поэтому вместе с указателем на массив держат длину или конец, как end в примерах выше, и следят за временем жизни массива. Как запретить изменение данных через указатель, разберём в следующем уроке.

Задача

Дан массив int a[6] = {4, 8, 15, 16, 23, 42};. Пройдите его указателем от a до конца a + 6 без квадратных скобок в цикле. Посчитайте элементы больше 10 и найдите индекс первого такого элемента через вычитание указателей. Ожидаемый вывод: count = 4 и first index = 2.

Разбор
C
#include <stdio.h>
#include <stddef.h>

int main(void)
{
    int a[6] = {4, 8, 15, 16, 23, 42};
    int *end = a + 6;
    int count = 0;
    ptrdiff_t first = -1;

    for (int *p = a; p != end; p++) {
        if (*p > 10) {
            if (first == -1) {
                first = p - a;
            }
            count++;
        }
    }
    printf("count = %d\n", count);
    printf("first index = %td\n", first);
    return 0;
}

Вывод:

count = 4
first index = 2

Указатель p проходит позиции от a до a + 5. На a + 6 цикл останавливается, и *end не читается. Первое число больше 10 равно 15 и лежит на a + 2, поэтому p - a даёт индекс 2. Значение -1 означает «пока не нашли»: в этом цикле p - a не бывает отрицательным.

Что запомнить

  • p хранит адрес, *p обозначает объект по нему, &p является адресом самого указателя.
  • p + i сдвигает на i элементов. Умножать на sizeof в коде не нужно.
  • *(p + i) и a[i] обозначают один и тот же элемент.
  • Для int a[5] допустимы указатели от a до a + 5. a + 5 нельзя разыменовывать, а a - 1 и a + 6 нельзя даже вычислять.
  • Разность указателей одного массива имеет тип ptrdiff_t и печатается через %td. В наших задачах < и > применяем внутри одного массива.
  • В sizeof(a) и &a массив не превращается в адрес первого элемента.
  • NULL нельзя разыменовывать и сдвигать. p != NULL не гарантирует ни живой объект, ни границы.
ПрактикаЗагружаем тест…