41. Указатель и массив: шаг, индекс и граница
Указатель на элемент массива можно сдвигать. Запись p + 1 даёт адрес следующего элемента, а не следующего байта. В этом уроке разберём, что именно хранит указатель и как он шагает по массиву. Затем найдём границу, за которую выходить нельзя, и посмотрим, почему массив всё-таки не указатель. Записи &x, *p, печать через %p и смысл NULL описаны в уроке про указатели. Передача массива в функцию разобрана в уроке про адреса и функции.
Что пригодится из прошлого: массивы, указатели, функции и адреса. Если эти темы знакомы, читайте дальше. Если нет, загляните по ссылке и возвращайтесь.
Указатель тоже лежит в памяти
Указатель является обычной переменной. Значит, у него есть своё место в памяти и свой адрес. Четыре записи легко перепутать:
| Запись | Что обозначает |
|---|---|
&x |
адрес переменной x |
p |
значение указателя: адрес, который в нём записан |
*p |
объект по этому адресу, то есть сама x |
&p |
адрес переменной p: место, где хранится сам указатель |
Проверим программой. Адреса меняются от запуска к запуску, поэтому печатаем не сами числа, а результаты сравнений: 1 означает «адреса равны», 0 означает «разные».
#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.
#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).
#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 элементов назад |
да |
Программа ниже двигает указатели только внутри массива из пяти элементов:
#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 ошибочны, даже если по ним ничего не читать. Уже само вычисление даёт неопределённое поведение.
Позиция за массивом удобна, чтобы обозначить конец. Цикл идёт от начала, пока указатель не станет равен концу:
#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.
#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 и в &.
#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 говорит только, что указатель не нулевой. Она не доказывает, что объект ещё существует, и не сообщает, сколько элементов можно пройти. Время жизни объекта означает период, пока он существует в памяти. У переменной внутри блока оно заканчивается вместе с блоком (область видимости). Фрагмент только для иллюстрации, запускать его не нужно:
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.
Разбор
#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не гарантирует ни живой объект, ни границы.
