Перейти к содержимому

const

  • Константные переменные и объекты структур
  • Копирование константного значения в неконстантный объект
  • Константные ссылки: чтение, наблюдение изменений и копирование значений
  • Константные параметры функций: передача по значению и по ссылке
  • Чтение через указатель на константный объект, перенаправление указателя и наблюдение изменений
  • Почему копирование адреса не снимает const с объекта
  • Константные элементы std::array
  • Размеры массивов, известные во время компиляции: const int и структуры с constexpr

Для каждого примера определите, скомпилируется ли он. Если да, что выведется? Какие объекты можно менять и через какие выражения?

Если main не показан, поместите код внутрь main. Во всех примерах подключите <array> и <iostream> перед кодом:

#include <array>
#include <iostream>
int main()
{
// snippet here
}
const int a = 5;
a = 6;
std::cout << a << std::endl;
Ответ

Программа не скомпилируется: a = 6 пытается изменить константный объект. При инициализации a получает значение, но после этого присваивать ему новое значение нельзя. Если убрать присваивание, выведется 5.

const int a = 5;
int b = a;
b = 6;
std::cout << a << std::endl;
std::cout << b << std::endl;
Выполнение по шагам
Ответ

Выведутся 5 и 6. b — отдельный неконстантный объект, в который при инициализации копируется значение a. Читать константный объект можно; изменение копии не меняет оригинал.

struct Position
{
int x;
int y;
};
int main()
{
const Position a{ 1, 2 };
a.x = 3;
std::cout << a.x << std::endl;
}
Ответ

Программа не скомпилируется: a.x = 3 пытается изменить поле константного объекта a. Сами поля объявлены как обычные int; константным является именно этот объект типа Position. Если убрать присваивание, выведется 1.

struct Position
{
int x;
int y;
};
int main()
{
const Position a{ 1, 2 };
Position b = a;
b.x = 3;
std::cout << a.x << std::endl;
std::cout << b.x << std::endl;
}
Выполнение по шагам
Ответ

Выведутся 1 и 3. Как и с int, константный объект можно скопировать в неконстантный. Значения полей копируются в b; b.x и a.x — разные объекты.

const int a = 5;
const int& r = a;
r = 6;
std::cout << r << std::endl;
Ответ

Программа не скомпилируется: r = 6 пытается изменить a через константную ссылку. r ссылается на существующий объект a, а не хранит копию его значения. const int& может ссылаться на константное число, но через такую ссылку разрешено только чтение. Если убрать присваивание, выведется 5.

6. Наблюдение изменения через константную ссылку

Заголовок раздела «6. Наблюдение изменения через константную ссылку»
int a = 5;
const int& r = a;
std::cout << r << std::endl;
a = 6;
std::cout << r << std::endl;
Выполнение по шагам
Ответ

Выведутся 5 и 6. Константная ссылка может ссылаться и на неконстантный объект. a по-прежнему можно менять напрямую, а через r читается текущее значение того же объекта. Ограничение запрещает запись через r, но не делает a неизменяемым.

7. Копирование значения, прочитанного через константную ссылку

Заголовок раздела «7. Копирование значения, прочитанного через константную ссылку»
int a = 5;
const int& r = a;
int b = r;
b = 6;
a = 7;
std::cout << r << std::endl;
std::cout << b << std::endl;
Выполнение по шагам
Ответ

Выведутся 7 и 6. int b = r копирует значение, прочитанное через r, в отдельный неконстантный объект. Изменение b не меняет a, а изменение a не меняет b. Ссылка r продолжает ссылаться на a.

8. Попытка создать неконстантную ссылку через константную

Заголовок раздела «8. Попытка создать неконстантную ссылку через константную»
int a = 5;
const int& r = a;
int& other = r;
other = 6;
Ответ

Программа не скомпилируется на строке int& other = r. Нельзя получить неконстантную ссылку на объект через константную ссылку, отбросив const. В отличие от int b = r, новый отдельный объект типа int здесь не создавался бы: other ссылалась бы на тот же объект и позволяла бы менять его. Правило действует, даже если именно этот объект a неконстантный. Можно написать const int& other = r, сохранив ограничение; тогда other = 6 тоже будет запрещено.

9. Поля структуры через константную ссылку

Заголовок раздела «9. Поля структуры через константную ссылку»
struct Position
{
int x;
int y;
};
int main()
{
Position a{ 1, 2 };
const Position& r = a;
r.x = 3;
std::cout << r.x << std::endl;
}
Ответ

Программа не скомпилируется: r.x = 3 пытается изменить целочисленное поле через константную ссылку. То же правило доступа только для чтения действует и для всей структуры. a.x = 3 было бы разрешено, потому что сам объект a неконстантный. Если убрать присваивание, выведется 1.

void func(const int a)
{
a = 6;
}
int main()
{
int a = 5;
func(a);
}
Ответ

Программа не скомпилируется: параметр a внутри func константный. При вызове значение аргумента копировалось бы в этот отдельный объект-параметр. const у параметра запрещает менять копию, но не делает переменную в вызывающей функции константной. То же правило действует для структуры, переданной по значению как const Position a.

11. Константный аргумент и неконстантный параметр

Заголовок раздела «11. Константный аргумент и неконстантный параметр»
void func(int a)
{
a = 6;
std::cout << a << std::endl;
}
int main()
{
const int a = 5;
func(a);
std::cout << a << std::endl;
}
Ответ

Выведутся 6 и 5. Константный аргумент копируется в обычный параметр типа int. Меняется только локальная копия, как в предыдущем примере с копированием числа.

12. Передача константной структуры по значению

Заголовок раздела «12. Передача константной структуры по значению»
struct Position
{
int x;
int y;
};
void func(Position a)
{
a.x = 3;
std::cout << a.x << std::endl;
}
int main()
{
const Position a{ 1, 2 };
func(a);
std::cout << a.x << std::endl;
}
Ответ

Выведутся 3 и 1. Здесь объединяются копирование структуры и передача по значению. Параметр — неконстантная копия: менять его поле можно, и на оригинал это не влияет.

struct Position
{
int x;
int y;
};
int readX(const Position& a)
{
return a.x;
}
int main()
{
Position a{ 1, 2 };
const Position b{ 3, 4 };
std::cout << readX(a) << std::endl;
a.x = 5;
std::cout << readX(a) << std::endl;
std::cout << readX(b) << std::endl;
}
Ответ

Выведутся 1, 5 и 3. В лабораторной по ссылкам параметр структуры с & использовался для изменения объекта в вызывающей функции. При добавлении const ссылка на исходный объект сохраняется, но через параметр его можно только читать. При каждом из этих вызовов объект типа Position не копируется.

Параметру типа const Position& можно передавать как константные, так и неконстантные объекты. Второй вызов читает обновлённое значение a.x, а если добавить a.x = 6 внутри readX, возникнет ошибка компиляции. Параметр по значению Position a создавал бы отдельную изменяемую копию, как в предыдущем примере.

int a = 5;
const int* p = &a;
*p = 6;
std::cout << *p << std::endl;
Ответ

Программа не скомпилируется: *p = 6 пытается записать значение через указатель на константный объект. Через const int* можно читать число, на которое он указывает, но нельзя менять его через p. Если убрать присваивание, выведется 5.

15. Перезапись указателя на константный объект

Заголовок раздела «15. Перезапись указателя на константный объект»
int a = 5;
int b = 6;
const int* p = &a;
p = &b;
std::cout << *p << std::endl;
Ответ

Выведется 6. Объект, к которому обращаются через p, нельзя менять через этот указатель, но сам p менять можно. Присваивание &b меняет сохранённый адрес, а не значения чисел.

Где ставить const?

const int* p и int const* p означают одно и то же: указатель на константный int. Здесь const относится к объекту, на который указывает p.

В int* const p = &a слово const относится к самой переменной-указателю: p = &b запрещено, но *p = 6 разрешено, если a неконстантный. const int* const p = &a запрещает оба изменения.

В этой лабораторной основной акцент на const T*: чтении объекта через указатель.

16. Доступ к полям структуры через указатель на константный объект

Заголовок раздела «16. Доступ к полям структуры через указатель на константный объект»
struct Position
{
int x;
int y;
};
int main()
{
Position a{ 1, 2 };
const Position* p = &a;
p->x = 3;
std::cout << p->x << std::endl;
}
Ответ

Программа не скомпилируется: p->x = 3 пытается изменить объект через const Position*. Через p можно читать оба целочисленных поля, но нельзя менять ни одно из них. Если убрать присваивание, выведется 1.

17. Наблюдение изменения через указатель на константный объект

Заголовок раздела «17. Наблюдение изменения через указатель на константный объект»
struct Position
{
int x;
int y;
};
int main()
{
Position a{ 1, 2 };
const Position* p = &a;
std::cout << p->x << std::endl;
a.x = 3;
std::cout << p->x << std::endl;
}
Ответ

Выведутся 1 и 3. a остаётся неконстантным объектом, и его можно менять напрямую. Указатель не хранит застывшую копию a: при каждом чтении он обращается к текущему значению поля того же объекта. const Position* ограничивает доступ через этот указатель, а не все способы обращения к a.

struct Position
{
int x;
int y;
};
int main()
{
Position a{ 1, 2 };
const Position* p = &a;
Position* q = p;
q->x = 3;
}
Ответ

Программа не скомпилируется на строке Position* q = p. Нельзя инициализировать обычный указатель из указателя на константный объект, отбросив const у объекта.

В отличие от Position b = a, копирование указателя копирует адрес, а не объект типа Position. Если бы такое преобразование было разрешено, через q можно было бы менять тот же объект. Можно написать const Position* q = p, сохранив ограничение; тогда q->x = 3 тоже будет запрещено. Преобразование запрещено, даже если именно этот объект a неконстантный.

19. Копирование значения, прочитанного через указатель на константный объект

Заголовок раздела «19. Копирование значения, прочитанного через указатель на константный объект»
struct Position
{
int x;
int y;
};
int main()
{
const Position a{ 1, 2 };
const Position* p = &a;
Position b = *p;
b.x = 3;
std::cout << p->x << std::endl;
std::cout << b.x << std::endl;
}
Ответ

Выведутся 1 и 3. Position b = *p читает и копирует весь объект, а не его адрес. Новый объект b неконстантный, поэтому его поля можно менять. Здесь чтение через указатель объединяется с уже знакомым правилом копирования структуры.

20. Параметр-указатель на константный объект

Заголовок раздела «20. Параметр-указатель на константный объект»
struct Position
{
int x;
int y;
};
int readX(const Position* p)
{
return p->x;
}
int main()
{
Position a{ 1, 2 };
const Position b{ 3, 4 };
std::cout << readX(&a) << std::endl;
std::cout << readX(&b) << std::endl;
}
Ответ

Выведутся 1 и 3. Функция получает копию адреса, а не копию структуры. Она может читать исходный объект, но не может менять его целочисленные поля через p. Если добавить p->x = 5 внутри readX, возникнет ошибка компиляции. Параметру типа const Position* можно передать адрес как неконстантного, так и константного объекта. Сам локальный параметр-указатель по-прежнему можно перенаправить, как в предыдущем примере с указателем.

21. Возврат неконстантного указателя на поле

Заголовок раздела «21. Возврат неконстантного указателя на поле»
struct Position
{
int x;
int y;
};
int* addressOfX(const Position& a)
{
return &a.x;
}
int main()
{
Position a{ 1, 2 };
int* p = addressOfX(a);
*p = 5;
std::cout << a.x << std::endl;
}
Ответ

Программа не скомпилируется на строке return &a.x. Через константную ссылку поле a.x тоже константное, поэтому &a.x имеет тип const int*. Превращение его в int* отбросило бы const — так же, как привязка int& к константной ссылке. Если бы это было разрешено, вызывающий код мог бы менять объект через возвращённый указатель в обход ограничения параметра. С возвращаемым типом const int* код скомпилируется, но тогда запрещено уже *p = 5.

struct Holder
{
int* p;
};
int* storedPointer(const Holder& h)
{
return h.p;
}
int main()
{
int value = 1;
Holder holder{ &value };
int* p = storedPointer(holder);
*p = 5;
std::cout << value << std::endl;
}
Ответ

Выведется 5. Через константную ссылку поле h.p константное: h.p = nullptr не скомпилируется. Но поле — это сам указатель, а не число, на которое он указывает. Его тип — int* const, поэтому при возврате копируется адрес, и получается значение типа int*, а копировать константное значение можно. Число value не входит в структуру, поэтому const его не защищает.

const std::array<int, 2> arr{ 1, 2 };
arr[0] = 3;
std::cout << arr[0] << std::endl;
Ответ

Программа не скомпилируется: элементы arr — константные числа. Их можно читать, но arr[0] = 3 пытается изменить один из них. Если убрать присваивание, выведется 1.

const std::array<int, 2> arr{ 1, 2 };
std::array<int, 2> other = arr;
other[0] = 3;
std::cout << arr[0] << std::endl;
std::cout << other[0] << std::endl;
Выполнение по шагам
Ответ

Выведутся 1 и 3. Весь массив копируется в неконстантный объект other. Как и при копировании константной структуры, копию можно менять независимо от оригинала.

const std::array<int, 2> arr{ 1, 2 };
int* p = arr.data();
Ответ

Программа не скомпилируется: для этого константного массива arr.data() возвращает const int*. Если инициализировать int* этим адресом, будет отброшен const у объекта, на который указывает указатель. Для чтения элементов можно написать const int* p = arr.data(); записывать через этот указатель по-прежнему нельзя.

4. Чтение массива через указатель на константный объект

Заголовок раздела «4. Чтение массива через указатель на константный объект»
std::array<int, 2> arr{ 1, 2 };
const int* p = arr.data();
arr[0] = 3;
std::cout << *p << std::endl;
p += 1;
std::cout << *p << std::endl;
Ответ

Выведутся 3 и 2. Указатель получает адрес первого элемента массива. *p читает текущее значение arr[0], которое изменили напрямую. Указатель можно передвинуть к следующему элементу, но присваивание *p = 4 не разрешено. Здесь доступ к массиву и арифметика указателей объединяются с чтением через указатель на константный объект.

5. Константные числа в качестве размеров массивов

Заголовок раздела «5. Константные числа в качестве размеров массивов»
const int globalSize = 2;
int main()
{
const int localSize = 3;
std::array<int, globalSize> a{ 1, 2 };
std::array<int, localSize> b{ 3, 4, 5 };
std::cout << a[1] << std::endl;
std::cout << b[2] << std::endl;
}
Ответ

Выведутся 2 и 5. Оба размера — константные числа, инициализированные константными выражениями, поэтому их значения можно использовать во время компиляции. Глобальная переменная не обязательна: локальный localSize тоже подходит. Здесь речь о размере, известном во время компиляции, а не о ключевом слове static.

6. Константное значение не всегда известно во время компиляции

Заголовок раздела «6. Константное значение не всегда известно во время компиляции»
int computeSize()
{
int width = 2;
int height = 3;
return width * height;
}
int main()
{
const int size = computeSize();
std::array<int, size> arr{};
}
Ответ

В стандартном C++ программа не скомпилируется на строке std::array<int, size> arr{}. size нельзя перезаписать, но его инициализатор вызывает функцию, которая не объявлена с constexpr. Этот вызов не является константным выражением, даже если компилятор может заменить его готовым значением при оптимизации. Аргумент размера шаблона std::array должен быть константным выражением.

struct Sizes
{
int count;
};
int main()
{
const Sizes sizes{ 3 };
std::array<int, sizes.count> arr{ 1, 2, 3 };
std::cout << arr[2] << std::endl;
}
Ответ

Программа не скомпилируется: sizes.count не является константным выражением, пригодным для размера массива. const запрещает изменять sizes, но не делает поля этой структуры доступными в константных выражениях. Правило, позволяющее использовать const int localSize = 3 как размер массива, не распространяется на константную структуру.

struct Sizes
{
int count;
};
int main()
{
constexpr Sizes sizes{ 3 };
std::array<int, sizes.count> arr{ 1, 2, 3 };
std::cout << arr[2] << std::endl;
}
Ответ

Выведется 3. Переменная с constexpr должна быть инициализирована константным выражением и также является константной. Здесь весь объект типа Sizes инициализирован во время компиляции, поэтому sizes.count можно использовать как аргумент размера шаблона.

В предыдущем случае const int localSize = 3 слово constexpr не требовалось, чтобы использовать значение как размер. Для этой структуры одного const Sizes sizes{ 3 } недостаточно: sizes.count не станет константным выражением, пригодным для размера массива. constexpr явно даёт такую гарантию для этого объекта.

Это расширяет использование числовых аргументов размера из лабораторной по массивам C++.