42. const и указатели: что разрешено менять
Слово const рядом с указателем запрещает одно из двух действий: менять значение по адресу или менять сам адрес в указателе. Какое именно, зависит от места const относительно звёздочки. Для урока нужны указатели, передача адресов в функцию и шаг указателя по массиву.
Что пригодится из прошлого: указатели, функции и адреса, указатель и массив. Если эти темы знакомы, читайте дальше. Если нет, загляните по ссылке и возвращайтесь.
Что вообще можно менять
С указателем связаны два объекта: сам указатель p, в котором записан адрес, и объект *p, на который он смотрит. Отсюда два действия из урока про указатели:
p = &y;переставляет стрелку;*p = 5;меняет значение по стрелке.
Слово const означает «через это имя менять нельзя». Компилятор проверяет запрет при сборке: если программа его нарушает, она не скомпилируется.
p *p
┌──────────────┐ ┌──────────────┐
│ адрес │ ─────► │ значение │
└──────────────┘ └──────────────┘
const после * const до *
защищает это защищает это
Правило и таблица
Смотрите, по какую сторону от звёздочки стоит const:
constдо*защищает объект: запись*p = ...запрещена;constпосле*защищает сам указатель: записьp = ...запрещена.
Порядок слов const int и int const не важен, оба означают «константный int». Объявление также удобно читать справа налево от имени: int *const p звучит как «p является константным указателем на int».
| Объявление | Как читается | p = &y; |
*p = 5; |
|---|---|---|---|
const int *p |
указатель на константный int |
можно | нельзя |
int const *p |
то же самое | можно | нельзя |
int *const p |
константный указатель на int |
нельзя | можно |
const int *const p |
константный указатель на константный int |
нельзя | нельзя |
Указатель с const после звёздочки потом не переставить, поэтому адрес ему дают сразу в объявлении.
Указатель на константный int
#include <stdio.h>
int main(void)
{
int x = 10;
int y = 20;
const int *p = &x;
printf("*p = %d\n", *p);
p = &y;
printf("*p = %d\n", *p);
return 0;
}
Вывод:
*p = 10
*p = 20
Указатель сначала смотрел на x, потом его переставили на y, и это разрешено. Строка *p = 5; в этой программе остановила бы сборку: компилятор сообщает о записи в объект только для чтения. Объявление int const *p = &x; означает то же самое.
Константный указатель
#include <stdio.h>
int main(void)
{
int x = 10;
int *const p = &x;
*p = 15;
printf("x = %d\n", x);
*p += 1;
printf("x = %d\n", x);
return 0;
}
Вывод:
x = 15
x = 16
Записи *p = 15; и *p += 1; изменили x, потому что объект не защищён. Защищён адрес: строка p = &y; не скомпилировалась бы. Пока этот указатель существует, он хранит адрес x.
Оба запрета
#include <stdio.h>
int main(void)
{
int x = 7;
const int *const p = &x;
printf("*p = %d\n", *p);
printf("p == &x: %d\n", p == &x);
return 0;
}
Вывод:
*p = 7
p == &x: 1
Через p можно только читать и сравнивать. Сравнение p == &x допустимо: указатели const int * и int * различаются только словом const, их можно сравнивать.
const запрещает запись только через это имя
Указатель на const удобно называть взглядом только для чтения: через него смотрят на объект, но не меняют его. Сам объект при этом не обязан быть константным.
#include <stdio.h>
int main(void)
{
int x = 10;
const int *view = &x;
printf("*view = %d\n", *view);
x = 20;
printf("*view = %d\n", *view);
return 0;
}
Вывод:
*view = 10
*view = 20
Переменная x объявлена без const, поэтому x = 20; разрешено. Указатель view не хранит копию, он читает текущее значение и видит 20. Запрет касается только записи через view.
Отсюда правило преобразований. Адрес int можно положить в const int *: запрет добавляется, и это безопасно. Обратно нельзя. Во фрагменте const int y = 10; int *q = &y; компилятор сообщит, что const отбрасывается, а с -Werror сборка остановится.
Приведение типа во фрагменте int *q = (int *)&y; может убрать такую диагностику. Но запись *q = 12; в настоящий константный объект даёт неопределённое поведение: язык не говорит, что произойдёт. Программа может напечатать старое значение, новое или аварийно завершиться. Запускать такой код «для проверки» бессмысленно: любой результат на одной машине ничего не доказывает.
Объявление int *a, b;
Звёздочка и const после неё относятся к одному имени. Тип слева, int или const int, относится ко всем именам в строке.
| Объявление | a |
b |
|---|---|---|
int *a, b; |
указатель на int |
int |
int *a, *b; |
указатель на int |
указатель на int |
const int *a, b; |
указатель на const int |
const int |
int *const a = &x, b = 0; |
константный указатель на int |
int |
Проверим первую строку таблицы:
#include <stdio.h>
int main(void)
{
int x = 1;
int *a = &x, b = 5;
b = *a + b;
printf("b = %d\n", b);
return 0;
}
Вывод:
b = 6
a получил адрес x, а b является обычным int со значением 5. Сумма *a + b равна 1 + 5. Чтобы не гадать, пишите по одному объявлению на строку.
Функция, которая только читает массив
В уроке про адреса и функции функция получала адрес первого элемента и могла менять массив. Если функция должна только читать, параметр объявляют как const int *. Длину передают отдельно. В примере n — неотрицательное число, не больше количества доступных элементов. Значения и их сумма должны помещаться в int.
#include <stdio.h>
int sum(const int *arr, int n)
{
int total = 0;
for (int i = 0; i < n; i++) {
total += arr[i];
}
return total;
}
int main(void)
{
int a[4] = {1, 2, 3, 4};
printf("sum = %d\n", sum(a, 4));
a[0] = 10;
printf("sum = %d\n", sum(a, 4));
return 0;
}
Вывод:
sum = 10
sum = 19
Параметр const int *arr является обещанием: функция не меняет элементы. Строка arr[i] = 0; внутри sum не скомпилировалась бы, потому что arr[i] означает *(arr + i), а это const int. Массив a в main объявлен без const, поэтому main меняет a[0], и вторая сумма равна 19. Запись const int arr[] в параметре означает то же самое.
const не проверяет границы. Вызов sum(a, 10) для массива из четырёх элементов скомпилируется, и функция прочитает за массивом, а это неопределённое поведение. Правильную длину обеспечивает вызывающий, как и в уроке про указатель и массив.
Задача
Напишите функцию int count_equal(const int *arr, int n, int value), которая считает, сколько раз value встречается в массиве. Пройдите массив указателем до конца arr + n. Условие: arr указывает на существующий массив, а n находится от нуля до его длины. Для массива {2, 7, 2, 2, 5} и значения 2 программа должна напечатать count = 3. Объясните, почему внутри функции разрешено p++, хотя элементы менять нельзя.
Разбор
#include <stdio.h>
int count_equal(const int *arr, int n, int value)
{
int count = 0;
const int *end = arr + n;
for (const int *p = arr; p != end; p++) {
if (*p == value) {
count++;
}
}
return count;
}
int main(void)
{
int a[5] = {2, 7, 2, 2, 5};
printf("count = %d\n", count_equal(a, 5, 2));
return 0;
}
Вывод:
count = 3
Указатель p имеет тип const int *: const стоит до звёздочки и защищает элементы, а не сам указатель. Поэтому p++ разрешено, а запись *p = 0; не скомпилировалась бы. Цикл останавливается на end, позиции за массивом, и её не читает. Число 2 стоит на позициях 0, 2 и 3, отсюда 3.
Что запомнить
constдо*защищает объект,constпосле*защищает сам указатель.const int *pиint const *pозначают одно и то же.- Указатель на
constзапрещает запись только через себя. Исходная неконстантная переменная по-прежнему меняется. - Изменять настоящий
constобъект через приведение типа нельзя: это неопределённое поведение. - В
int *a, b;указатель толькоa. - Параметр
const int *arrобещает не менять массив, но границы не проверяет. Длину передают отдельно.
