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

Базовое взаимодействие с памятью через переменные

  • Память: стек (временная), хип (динамическая)
  • Переменная как абстракция для ячейки памяти
  • Операции с переменными (считать, вписать)
  • Значение
  • Объект
  • Адрес памяти
  • Ссылка (адрес памяти объекта)
  • Типы данных
  • Тип-значение и ссылочный тип
  • Выражение (есть больше об этом в следующей теме)
  • Вывод типа через var

Объясните, что произойдет в следующих отрезках кода:

  • какие выполнятся инструкции и как,
  • сколько ячеек памяти выделится во временной памяти,
  • какое значение куда запишется,
  • сколько объектов выделится в динамической памяти,
  • что будет в переменных по итогу выполнения программы,
  • что напечатается в консоль.

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

int a = 5;
Console.WriteLine(a);
Правильный ответ:

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

Напечатается 5.

int a = 5;
int b = 6;
a = b;
b = 7;
Console.WriteLine(a);
Правильный ответ:

В a запишется 6 на 3-ей строчке. Запись в b 7 на 4-ой строчке не влияет на ячейку памяти переменной a.

Важно помнить, что инструкции выполнятся по очереди, сверху вниз.

Также важно помнить, что ячейку нельзя связать с другой ячейкой по имени. a = b копирует из ячейки b в ячейку a. Это одноразовое действие, они не будут связаны после выполнения этой строчки. Как бы вы не влияли на b после этого, это не отразится в a.

int a = 1;
int b = 2;
a = b;
b = a;
Console.WriteLine(a);
Console.WriteLine(b);
Правильный ответ:

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

Однако a = b перезаписывает a, и старое значение 1 из a пропадает. Поэтому напечатается 2 и 2.

Правильный обмен делается через временную переменную:

int a = 1;
int b = 2;
int temp = a;
a = b;
b = temp;

4. Присваивание выражения, включающего переменную

Заголовок раздела «4. Присваивание выражения, включающего переменную»
int a = 5;
int b = a + 6;
a = 7;
Console.WriteLine(b);
Правильный ответ:

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

a + 6 -> 5 + 6 -> 11

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

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

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

Заголовок раздела «5. Литералы, переменные и операторы — это выражения»

Найдите в этом коде все выражения и перечислите их.

int a = 5;
int b = a;
int c = a + 6;
Console.WriteLine(b);
Console.WriteLine(c);
Что такое выражение?

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

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

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

int b = a сам по себе не является выражением. Только a внутри является выражением. int b = a - это statement, на русском я это называю инструкция.

Правильный ответ: Напечатается `5` и `11`.
int a = 5;
int c = (a = 7);
Console.WriteLine(a);
Console.WriteLine(c);
Правильный ответ:

Само присваивание (a = 7) — это тоже выражение: оно записывает 7 в a, а затем даёт как результат то значение, которое установилось после присваивания (то есть 7).

Это значение затем записывается в c.

Напечатается 7 и 7.

Какие объекты создаются в этом коде, какие в нём есть переменные и что хранится в каждой из них?

string a = "1";
string b = a;
a = "2";
Console.WriteLine(a);
Console.WriteLine(b);
Правильный ответ:

string a = "1"; делает 3 вещи:

  • Создает ячейку памяти для a во временной памяти;
  • Создает объект в динамической памяти с представлением строки "1";
  • Сохраняет в ячейку памяти для a адрес объекта строки (ссылка на строку) в динамической памяти "1".

На 2-й строчке в новую ячейку b попадает результат выражения a (адрес объекта строки "1" в динамической памяти).

Строка a = "2" перезаписывает ссылку, хранящуюся в a, а не значение в объекте по адресу из a, на адрес свежесозданного объекта строки "2". Следовательно, это не повлияет на значение по ссылке из b (то есть не сменит "1" на "2" в объекте строки "1").

По итогу в a будет ссылка на объект "2", а в b будет ссылка на объект "1".

string a = 5;
Правильный ответ:

Несовместимость типов: в a можно сохранять только ссылки на строки, а мы пытаемся сохранить там число.

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

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

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

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

int a = 5;
a = 6;
int a = 5;
int A = 6;
Console.WriteLine(a);
Console.WriteLine(A);
Правильный ответ:

C# чувствителен к регистру букв в именах переменных и других сущностей. a и A — это две разные переменные.

Напечатается 5 и 6.

console.WriteLine("Hello");
Правильный ответ:

Произойдет ошибка компиляции, потому что C# чувствителен к регистру букв: WriteLine нужно писать с большой буквы, а сам тип — Console с большой буквы. console маленькими буквами это другое имя, а такого имени нет:

error CS0103: The name 'console' does not exist in the current context
var a = 5;
Console.WriteLine(a);
Правильный ответ:

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

Напечатается 5.

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

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

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

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

int a = 5;
var b = a + 5;
Console.WriteLine(b);
Правильный ответ:

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

Напечатается 10.