bulgakov

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

C
#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; означает то же самое.

Константный указатель

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

Оба запрета

C
#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 удобно называть взглядом только для чтения: через него смотрят на объект, но не меняют его. Сам объект при этом не обязан быть константным.

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

Проверим первую строку таблицы:

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

C
#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++, хотя элементы менять нельзя.

Разбор
C
#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 обещает не менять массив, но границы не проверяет. Длину передают отдельно.
ПрактикаЗагружаем тест…