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

Переменные и типы

  • Переменная как абстракция для ячейки памяти
  • Относительное расположение памяти переменных в оперативной памяти
  • Определение и объявление переменных
  • Операции с переменными (считать, вписать)
  • Неинициализированные переменные, мусорные данные
  • UB (undefined behavior)
  • Синтаксис инициализации
  • Значение
  • Выражение, процесс вычисления выражения
  • Типы данных: знак (минус), размер

Объясните, что произойдет в следующих отрезках кода. Также, запустите данный код, чтобы убедиться в правильности вашей логики.

Там, где main не был расписан, код помещается в типичный основной файл:

#include <iostream>
#include <cstdint>
int main()
{
// сюда
}
int a = 5;
std::cout << a << std::endl;
Какой тип у a?

int. Тип идет перед именем переменной.

int означает, что в a можно будет записать целое число.

int a;
std::cout << a << std::endl;
Ответ

Данный код не скомпилируется, если подключить флаги -Werror и -Wall при компиляции. Если их не дать, скомпилируется и запустится, но результат возможно будет не такой, какой вы ожидаете.

a является неинициализированной переменной. Важно понимать, что это не значит, что в a нет значения. В a не может не быть значения, поскольку a это всего лишь абстракция для ячейки памяти, а в ячейке памяти не может не быть ничего.

Неинициализированная переменная в C++ это та переменная, куда еще не было нарочно записано значение.

Объявление переменной всего лишь выделяет ячейку памяти для этой переменной. Заметьте, что ячейка приходит из общей памяти и могла до этого использоваться другой переменной. Такие ячейки памяти остаются с их старым значением, которое было там при прошлом их использовании. По этой причине, в переменной может быть любое число, а вы как программист не можете полагаться на то, что там будет.

То, что находится в неинициализированной переменной по другому называется мусорные данные.

Почему в ячейке памяти не может не быть ничего?

Потому что память состоит из байтов, которые состоят из 8 битов каждый. Биты способны хранить в себе или 0, или 1, и ничто другое. Они не могут хранить в себе “ничего”. Соответственно и байты, состоящие строго из битов, не способны хранить что либо кроме 0 или 1 составляющих их битов.

Вы могли бы решить, что 0 это “ничего”, но это не всегда так. 0 можно вписать в бит нарочно.

Если 0 и “ничего” это одно и то же, то вы не сможете различить, который из них в бите, если в изоляции считаете 0 из бита. Был ли там 0 потому что туда еще ничего не вписали, или потому что кто-то туда нарочно его вписал ранее?

Что будет если считать из переменной a?

Поскольку a неинициализированная, вы получите то значение, которое было в памяти, выделенной a еще до того, как она была выделена a.

Однако, считывание из неинициализированной переменной считается UB (undefined behavior), что по определению означает, что может произойти все что угодно, а компилятору разрешается предположить, что такое действие невозможно.

int a = 5;
int a = 6;
std::cout << a << std::endl;
Правильный ответ:

Переопределять переменные с тем же именем нельзя. Это запрещено, даже если второе определение другого типа:

int a = 5;
double a = 6; // ошибка тоже: переопределение `a`

Можно только перезаписать значение существующей переменной:

int a = 5;
a = 6;

4. Присваивание переменной к другой переменной

Заголовок раздела «4. Присваивание переменной к другой переменной»
int a = 5;
int b = 6;
a = b;
b = 7;
std::cout << a << std::endl;
Выполнение по шагам

Какие выражения есть в этом фрагменте кода?

int a = 5;
int b = a + 6;
a = 7;
std::cout << b << std::endl;
Выполнение по шагам
Что произойдёт?

На строчке 2 в b записывается результат выражения с правой части присваивания (a + 6). Вычисление результата этого выражения означает его превращение в одно значение.

a + 6 -> 5 + 6 -> 11

Результатом вычисления выражения является значение 11, которое и будет записано в ячейку b.

Дальнейшее изменение a не влияет на предыдущую операцию, поскольку ее результат уже был сохранен в b.

Что здесь считается выражением?

Литерал (5, 6, 7), чтение переменной (a). Каждое из них при вычислении даёт одно значение со своим типом (здесь все int).

Даже всё присваивание целиком (a = 7) — это выражение. Почему? Потому что его результат можно присвоить, например, другой переменной.

Например, следующий код записывает 7 в a, вычисляя a = 7, которое само даёт 7 (то значение, которое установилось после присваивания), а оно затем записывается в c.

int c = (a = 7);

Даже b на строчке std::cout << b << std::endl; — это выражение, потому что его значение будет передано в функцию печати, а для этого оно должно быть сначала вычислено — например, в число — прежде чем отправиться в функцию печати.

6. Литералы, переменные и операторы — это выражения

Заголовок раздела «6. Литералы, переменные и операторы — это выражения»
int a = 5;
int b = a;
int c = a + 6;
std::cout << b << std::endl;
std::cout << c << std::endl;
Выполнение по шагам
Ответ

Литералы, чтения переменных и применения операторов к выражениям — всё это выражения. Каждое из них при вычислении даёт одно значение со своим типом:

  • 5 — это литерал, который сам является выражением: он при вычислении даёт самого себя и имеет тип int;
  • a на строчках int b = a; и int c = a + 6; — это чтение переменной, то есть выражение: оно даёт значение, которое сейчас хранится в a (здесь это 5);
  • a + 6 — это выражение с оператором: оператор +, применённый к двум выражениям (a и 6), даёт одно значение (11).

То есть int b = a; копирует в b результат выражения a, а int c = a + 6; копирует в c результат выражения a + 6.

Напечатается 5 и 11. При печати b и c тоже являются выражениями: чтение этих переменных даёт сохранённые значения 5 и 11.

int a = "abc";
Правильный ответ:

Ошибка несовместимости типов при компипляции.

Нельзя вписать значение строчного литерала "abc" в ячейку, хранящую int.

"ggg" >> std::cout;
Ответ

Не компилируется. Поток вывода ставится слева, а для вывода используется <<: std::cout << "ggg";. Перестановка операндов и замена оператора не дают равнозначного выражения.

int a{5};
Правильный ответ:

Этот синтаксис по большей части эквивалентен следующему:

int a = 5;

Разница в том, что он заставляет компилятор дать ошибку в том случае, когда такое присваивание влечет за собой возможную потерю информации.

Например, следующий код скомпилируется, если не дать компилятору никаких флагов. При запуске, в a будет сохранено число 5 (дробная часть будет отсечена).

int a = 5.6;

Если использовать фигурные скобки, не скомпилируется. Эта строгость может помочь нам заметить возможные ошибки.

int a{ 5.6 };
int a{};
std::cout << a << std::endl;
Выполнение по шагам
Ответ

Пустые фигурные скобки означают, что в переменную сразу записывается значение по умолчанию.

Для int это значение — 0, поэтому в a будет сохранено число 0 и напечатается 0.

Это отличается от int a;: там a остаётся неинициализированной, и в ней лежат мусорные данные (см. пример 2). Поэтому считать значение из a здесь можно — в отличие от неинициализированной переменной, это не UB.

int a{ 7 };
a = {};
std::cout << a << std::endl;
Выполнение по шагам
Ответ

Печатает 0. a = {} присваивает значение int после инициализации значением, то есть ноль. Переменная a не становится неинициализированной.

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

Дважды печатает 0. int{} — выражение типа int со значением ноль. Одно и то же выражение можно использовать для присваивания и для инициализации.

std::cout << sizeof(int) << std::endl;
std::cout << sizeof(uint8_t) << std::endl;
int a;
std::cout << sizeof(a) << std::endl;
Ответ:

sizeof вычисляется во время компиляции, давая размер переменной или типа в байтах. Во время выполнения его уже нет: компилятор заменяет sizeof(...) на обычное число, так что никакого sizeof в выполняемом коде уже не остаётся.

Например:

  • sizeof(int) даст 4;
  • sizeof(a) эквивалентен sizeof(тип_а), то есть sizeof(int), то есть 4;
  • sizeof(uint8_t) даст 1 (8 бит — 1 байт).

Операнд при этом на самом деле не вычисляется. В sizeof(a + 1) выражение a + 1 не вычисляется; компилятор определяет только тип его результата (здесь int), потому что типы существуют только во время компиляции и к моменту выполнения уже недоступны.

Какой тип будет у a в данном примере?

auto a = 5;
Что значит auto?

auto значит, что тип автоматически выводится из типа выражения, которым инициализируется переменная, а не просто из текста справа. Так как у выражения 5 тип int, у a тип автоматически станет int.

Можете представить, что auto как бы заменится на int во время компиляции.

Выведенный тип статический (фиксируется при компиляции) и поменяться позже не может:

auto a = 5;
a = "abc"; // ошибка: `a` — это `int`, позже он не может стать строкой
auto a;
a = 5;
Ответ

Это не скомпилируется: auto нужно выражение, из которого выводится тип. Без выражения компилятору нечем заменить auto. Присваивание a = 5; на следующей строке этого не исправляет — тип должен быть зафиксирован при определении и не может быть выведен из последующего присваивания.

auto a{ 5 };
Ответ

Выражение 5 имеет тип int, поэтому у a тип int и значение 5. В фигурных скобках одно выражение инициализации, как и в auto a = 5;.

int a{ 5 };
auto b{ a + 5 };
Ответ

auto учитывает тип всего выражения, а не то, является ли оно литералом. У a + 5 тип int, поэтому b станет int со значением 10. То же верно для любого выражения: auto c{ a }; тоже даст c тип int.

int a { 1 };
int b { 2 };
a = b;
b = a;
std::cout << a << std::endl;
std::cout << b << std::endl;
Выполнение по шагам
Ответ

Похожий код с первого взгляда выглядит как попытка сменить значения a и b местами, чтобы в a было 2, а в b было 1.

Однако, a = b перезаписывает a, и старое значение 1 из a пропадает.

Правильный код был бы:

int a { 1 };
int b { 2 };
// временная переменная
int temp { a };
a = b;
b = temp;

Числовые преобразования рассматриваются в следующей лабораторной.