Ссылочные и значимые типы

1. Введение

Представьте, что у вас есть коробка. Если это коробка, которая содержит сам предмет (например, коробка с яблоком внутри), то это похоже на значимый тип. Сами данные находятся прямо в этой "коробке" (переменной).

С другой стороны, представьте, что у вас есть визитка с адресом. Сама визитка не является домом, она лишь указывает, где найти дом. Это похоже на ссылочный тип. Переменная в этом случае содержит не сами данные, а "визитку" – адрес в памяти, где эти данные расположены.

Простейшие примеры:

• int x = 5; // Значимый тип: переменная x "хранит" число 5 напрямую.
• string name = "Вася"; // Ссылочный тип: переменная name "хранит" ссылку на строку "Вася", которая находится где-то в памяти.

Кто есть кто в этой жизни?

Чтобы вам было проще ориентироваться, вот общий список того, к каким категориям относятся основные типы данных:

• Примитивные типы: int, double, float, bool, char, byte, short, long, decimal и т.д.
• Структуры (struct): Все пользовательские структуры, которые вы объявляете с помощью ключевого слова struct.
• Перечисления (enum): Типы, которые позволяют определить набор именованных констант.

• Строки (string): Хотя строки имеют некоторые особенности (они неизменяемы), они являются ссылочным типом.
• Все массивы: Например, int[], string[], YourCustomClass[].
• Все классы (class): Все пользовательские классы, которые вы объявляете с помощью ключевого слова class.
• Делегаты (delegate): Типы, которые представляют ссылки на методы.
• Интерфейсы (interface): Хотя сами интерфейсы не являются объектами, переменная типа интерфейса может хранить ссылку на объект, реализующий этот интерфейс.
• Списки, словари и другие коллекции: Например, List<T>, Dictionary<TKey, TValue>.
• И вообще, всё, что не является struct или enum, по умолчанию является ссылочным типом в C#.

2. Копирование переменных

Вот здесь-то и кроется основное практическое различие. Когда вы присваиваете одну переменную другой, что на самом деле копируется?

А) Копирование значимого типа (Value Type)

Когда вы копируете значимый тип, создается полноценная, независимая копия самих данных. Это как сделать ксерокопию документа: изменения в одной копии никак не влияют на оригинал или другие копии.

    int a = 10;
int b = a; 					// b теперь тоже 10, но это "своя копия"
Console.WriteLine($"Начальные значения: a = {a}, b = {b}"); // Начальные значения: a = 10, b = 10

b = 15; 					// Изменяем b
Console.WriteLine($"После изменения b: a = {a}, b = {b}"); // После изменения b: a = 10, b = 15

Объяснение: Переменная b получила свою собственную копию значения 10. Когда b было изменено на 15, a осталось со своим оригинальным значением 10. Они абсолютно независимы.

Б) Копирование ссылочного типа (Reference Type)

При копировании ссылочного типа копируется только ссылка, то есть "адрес" объекта в памяти. Обе переменные теперь указывают на один и тот же объект. Это похоже на то, как если бы вы дали двум людям одну и ту же визитку: они оба будут знать адрес одного и того же дома. Если один человек изменит что-то в доме (например, перекрасит стену), то и другой человек, придя по этому адресу, увидит эти изменения.

Давайте разберёмся на примере массивов, поскольку они очень наглядно демонстрируют "магию" ссылок (в отличие от строк, которые имеют свои нюансы).

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 и arr1 указывают на один и тот же массив в памяти!

// Начальные значения: arr1[0] = 1, arr2[0] = 1
Console.WriteLine($"Начальные значения: arr1[0] = {arr1[0]}, arr2[0] = {arr2[0]}"); 

arr2[0] = 42; // Изменяем элемент массива через arr2

// После изменения arr2[0]: arr1[0] = 42, arr2[0] = 42
Console.WriteLine($"После изменения arr2[0]: arr1[0] = {arr1[0]}, arr2[0] = {arr2[0]}"); 

Объяснение: Обе переменные (arr1 и arr2) содержат ссылку на один и тот же массив в памяти. Когда вы изменяете элемент arr2[0], вы фактически изменяете тот самый массив, на который указывают обе переменные. Поэтому arr1[0] также отображает измененное значение.

Нюанс со строками (string)

Строки в C# являются ссылочным типом, но ведут себя несколько иначе из-за их неизменяемости (immutability). Это означает, что после создания строку нельзя изменить. Любая операция, которая, казалось бы, "изменяет" строку (например, конкатенация, Replace()), на самом деле создает новую строку в памяти.

string str1 = "Hello";
string str2 = str1; // str2 ссылается на тот же объект "Hello", что и str1

// str1 = "Hello", str2 = "Hello"
Console.WriteLine($"Начальные значения: str1 = \"{str1}\", str2 = \"{str2}\""); 

str2 = "Bye"; // Здесь создается НОВЫЙ объект "Bye", и str2 начинает ссылаться на него

// str1 = "Hello", str2 = "Bye"
Console.WriteLine($"После изменения str2: str1 = \"{str1}\", str2 = \"{str2}\""); 

Объяснение: Изначально str1 и str2 ссылались на один и тот же объект "Hello". Когда str2 было присвоено "Bye", C# не изменил существующий объект "Hello". Вместо этого он создал новый объект "Bye" в памяти, и str2 теперь ссылается на этот новый объект. str1 по-прежнему ссылается на старый объект "Hello". Это важное отличие, которое часто сбивает с толку новичков.

3. Таблица основных различий

4. Пример в приложении

Представим, что мы разрабатываем простое консольное приложение для анкеты пользователя. У нас есть структура для баллов экзамена и класс для профиля пользователя.

// Значимый тип: структура для хранения баллов
struct Score
{
    public int Points;
    public string Grade; // Добавим для наглядности
}

// Ссылочный тип: класс для профиля пользователя
class User
{
    public string Name;
    public Score ExamScore; // Вложенная структура
}

Копирование структуры (Score)

Score score1 = new Score { Points = 100, Grade = "A" };
Score score2 = score1; // Копируется все содержимое score1 в score2
Console.WriteLine($"score1: Points={score1.Points}, Grade={score1.Grade}"); // score1: Points=100, Grade=A
Console.WriteLine($"score2: Points={score2.Points}, Grade={score2.Grade}"); // score2: Points=100, Grade=A

score2.Points = 88;
score2.Grade = "B";

Console.WriteLine("--- После изменения score2 ---");
Console.WriteLine($"score1: Points={score1.Points}, Grade={score1.Grade}"); // score1: Points=100, Grade=A (не изменился!)
Console.WriteLine($"score2: Points={score2.Points}, Grade={score2.Grade}"); // score2: Points=88, Grade=B

Результат: score1 остался прежним. Это произошло потому, что при Score score2 = score1; содержимое score1 (все его поля) было скопировано в score2. Обе переменные теперь содержат свои независимые наборы данных.

Копирование класса (User)

User u1 = new User 
{ 
    Name = "Анна", 
    ExamScore = new Score { Points = 95, Grade = "A" } 
};
User u2 = u1; // Теперь и u2, и u1 ссылаются на ОДНОГО и того же пользователя в памяти!
Console.WriteLine($"u1: Name={u1.Name}, Score={u1.ExamScore.Points}"); // u1: Name=Анна, Score=95
Console.WriteLine($"u2: Name={u2.Name}, Score={u2.ExamScore.Points}"); // u2: Name=Анна, Score=95

u2.Name = "Иван"; // Изменяем имя через u2
u2.ExamScore.Points = 60; // Изменяем баллы через u2
u2.ExamScore.Grade = "C";

Console.WriteLine("--- После изменения u2 ---");
Console.WriteLine($"u1: Name={u1.Name}, Score={u1.ExamScore.Points}, Grade={u1.ExamScore.Grade}"); // u1: Name=Иван, Score=60, Grade=C
Console.WriteLine($"u2: Name={u2.Name}, Score={u2.ExamScore.Points}, Grade={u2.ExamScore.Grade}"); // u2: Name=Иван, Score=60, Grade=C

Результат: u1 также изменился! Это произошло потому, что u1 и u2 изначально ссылались на один и тот же объект User в памяти. Когда мы изменили свойства объекта через u2 (например, u2.Name = "Иван";), мы фактически изменили сам объект. Поэтому, когда мы обращаемся к u1.Name, мы видим уже измененное значение. Даже вложенная структура ExamScore изменилась для u1, потому что она является частью объекта User, на который указывают обе ссылки.

5. Что происходит при передаче в методы

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

Передача значимого типа (Value Type) в метод

При передаче значимого типа в метод по умолчанию происходит передача по значению. Это означает, что метод получает копию исходной переменной. Любые изменения, сделанные внутри метода с этой копией, не влияют на оригинал за пределами метода.

void AddTen(int x)
{
    Console.WriteLine($"Внутри метода (до изменения): x = {x}"); // Внутри метода (до изменения): x = 5
    x = x + 10; // x теперь 15, но это локальная копия
    Console.WriteLine($"Внутри метода (после изменения): x = {x}"); // Внутри (после изменения): x = 15
    // Эта локальная копия 'x' "умрёт" после выхода из метода.
}

int num = 5;
Console.WriteLine($"До вызова метода: num = {num}"); // До вызова метода: num = 5
AddTen(num);
Console.WriteLine($"После вызова метода: num = {num}"); // После вызова метода: num = 5 (не изменился!)

Результат: Переменная num осталась неизменной (5). x внутри AddTen — это совершенно отдельная переменная, которая была инициализирована копией значения num.

Передача ссылочного типа (Reference Type) в метод

При передаче ссылочного типа в метод по умолчанию также происходит передача по значению, но копируется значение ссылки, а не сам объект. Это означает, что внутри метода вы получаете копию "визитки" (адреса) на оригинальный объект. Обе ссылки (оригинальная и та, что внутри метода) указывают на один и тот же объект в памяти.

void RenameUser(User u)
{
    // Внутри метода (до изменения): u.Name = "Ольга"
    Console.WriteLine($"Внутри метода (до изменения): u.Name = \"{u.Name}\""); 
    u.Name = "Новое имя"; // Изменяем свойство объекта, на который указывает 'u'
    // Внутри метода (после изменения): u.Name = "Новое имя"
    Console.WriteLine($"Внутри метода (после изменения): u.Name = \"{u.Name}\""); 
}

User user = new User { Name = "Ольга" };
// До вызова метода: user.Name = "Ольга"
Console.WriteLine($"До вызова метода: user.Name = \"{user.Name}\""); 
RenameUser(user); 
// После вызова метода: user.Name = "Новое имя"
Console.WriteLine($"После вызова метода: user.Name = \"{user.Name}\""); 

Результат: Имя пользователя изменилось на "Новое имя". Метод RenameUser получил копию ссылки на объект user. Через эту копию ссылки метод смог получить доступ к оригинальному объекту в куче и изменить его свойство Name.

Важное дополнение: Что произойдёт, если внутри метода мы присвоим новый объект переданной переменной ссылочного типа?

void ReassignUser(User u)
{
    u = new User { Name = "Совсем новый пользователь" }; // 'u' теперь ссылается на новый объект
    Console.WriteLine($"Внутри метода (после переприсвоения): u.Name = \"{u.Name}\"");
}

User originalUser = new User { Name = "Оригинальный пользователь" };
Console.WriteLine($"До вызова ReassignUser: originalUser.Name = \"{originalUser.Name}\"");
ReassignUser(originalUser); 
Console.WriteLine($"После вызова ReassignUser: originalUser.Name = \"{originalUser.Name}\""); // "Оригинальный пользователь" - не изменился!

Результат: originalUser не изменился! Это потому, что ReassignUser получил копию ссылки. Когда u = new User(...) произошло внутри метода, локальная переменная u стала указывать на совершенно новый объект. Оригинальная ссылка originalUser по-прежнему указывает на тот же самый старый объект. Это очень важный момент!

6. "Слёзы новичка": типичные ошибки и их причины

Понимание ссылочных и значимых типов может быть сложной задачей для начинающих. Вот некоторые распространённые ошибки и заблуждения:

Путаница с копированием массивов: Новички часто ожидают, что при присвоении arr2 = arr1; будет создана независимая копия массива. На самом деле, это всего лишь две ссылки на один и тот же массив. Это как два пульта управления к одной и той же игре: что бы вы ни нажали на одном пульте, это повлияет на игру, и это будет видно и на другом пульте. Чтобы создать независимую копию массива, нужно явно клонировать его (например, int[] arr2 = (int[])arr1.Clone(); или использовать методы Copy).

Ожидание изменения строк "по ссылке": Из-за того, что string является ссылочным типом, иногда предполагают, что он будет вести себя как массив в плане изменения. Однако, из-за неизменяемости строк, любая операция, кажущаяся изменением, на самом деле создаёт новый строковый объект. Это часто приводит к неожиданным результатам и может быть неэффективным при многократных операциях со строками в цикле (для этого лучше использовать StringBuilder).

Забывание о null: Значимые типы, за исключением nullable-типов (int?, bool?), всегда имеют какое-то значение и никогда не могут быть null. Ссылочные же типы могут быть null, то есть не указывать ни на один объект. Попытка получить доступ к члену объекта, который является null, приведет к печально известному NullReferenceException. Всегда проверяйте ссылочные переменные на null перед использованием, если есть вероятность, что они могут быть неопределенными.

Использование классов вместо структур для мелких данных: Иногда по привычке все объявляют классами. Для маленьких, простых наборов данных, которые представляют собой одно целое (например, точка Point { X, Y }, цвет Color { R, G, B }), структуры могут быть более производительными, так как они хранятся в стеке и копируются по значению, что снижает накладные расходы на сборку мусора. Однако, структуры должны быть неизменяемыми, небольшими и не должны содержать ссылочные типы, которые сами могут быть null или изменять свое состояние.

2

Задача

C# SELF, 12 уровень, 3 лекция

Недоступна

Поведение массивов как ссылочного типа

Поведение массивов как ссылочного типа

Открыть

2

Задача

C# SELF, 12 уровень, 3 лекция

Недоступна

Взаимодействие с методами для значимого и ссылочного типов

Взаимодействие с методами для значимого и ссылочного типов

Открыть