Модул 25

Стойностни и референтни типове – стек и heap

Как програмата пази данните си: стекът за локалните променливи и стойностните типове, динамичната памет (heap) за обектите, създадени с new. Защо int и struct се копират, а class, масив и string се споделят през референция, какво получава един метод като параметър, откъде идва NullReferenceException и защо == при класове не сравнява съдържанието.

Част от учебната програма

Теория

Когато програмата работи, паметта ѝ е разделена на две области с различни правила. Стекът (stack) е подредена купчина: всеки извикан метод слага отгоре своя „рамка“ с локалните си променливи и параметри, а когато методът приключи, рамката се маха и паметта се освобождава автоматично. Затова стекът е много бърз, но и строг: това, което живее в него, съществува само докато методът работи. Динамичната памет (heap) е голямо свободно пространство, в което с оператора new създаваме обекти, живеещи толкова дълго, колкото са нужни — независимо кой метод ги е създал. Когато вече никой не сочи към даден обект, събирачът на боклук (garbage collector, GC) го открива и освобождава мястото му; вие не изтривате нищо ръчно.

Стойностните типове (value types) пазят стойността направо в променливата: int, double, bool, char, decimal, изброяванията enum и всяка структура struct. Локална променлива от такъв тип живее в стека и съдържа самите данни, а не адрес. Присвояването int b = a; прави копие: след b = 10; променливата a остава непроменена, защото двете са отделни кутийки. Същото важи за структурите: Point p2 = p1; копира всички полета на p1 в p2 и оттам нататък двете точки са независими. Стойностните типове не могат да са null и имат стойност по подразбиране — 0 за числата, false за bool, а при struct всички полета са нулирани.

Референтните типове (reference types) — всеки class, всеки масив, string, интерфейсите и делегатите — работят по друг начин. Самият обект се създава с new в heap-а, а променливата пази само референция (reference): адреса, на който обектът се намира. Присвояването Student b = a; копира адреса, а не обекта — вече имате две променливи, сочещи към един и същ обект, и промяната b.Points = 100; се вижда и през a. Точно това изненадва при масивите: int[] copy = original; не прави копие; след copy[0] = 99; и original[0] е 99. Истинско копие се получава само ако изрично го поискате, например с (int[])original.Clone(), Array.Copy или с нов обект, чиито полета попълвате сами.

Подаването на аргумент на метод е по подразбиране по стойност (by value): параметърът е нова локална променлива, в която се копира това, което подавате. При int се копира числото, затова Change(n) с x = 10; в тялото оставя n непроменено. При клас или масив се копира референцията — методът получава втори адрес към същия обект, така че arr[0] = 0; вътре в него променя масива на извикващия. Но ако методът напише arr = new int[3];, той пренасочва само своята локална референция, а променливата отвън продължава да сочи към стария масив. Когато искате методът да променя самата променлива на извикващия, обявете параметъра с ref (или out за стойност, която методът задължително връща) и подайте аргумента също с ref: Swap(ref a, ref b).

Референтна променлива може да не сочи към нищо — тогава стойността ѝ е null. Такива са полетата от референтен тип, които не сте инициализирали, елементите на нов масив от обекти (new Student[5] съдържа пет null) и резултатът от метод, който „не намира“ нищо. Опитате ли да достъпите член през null — s.Name, arr.Length, list.Add(...) — програмата се срива с NullReferenceException: няма обект, от който да се вземе полето. Защитата е проста: проверете if (s != null) преди точката, използвайте оператора ?. (s?.Name връща null, вместо да гръмне) и ?? за стойност по подразбиране (name ?? "Непознат"). В .NET 8 проектите нулируемите референции са включени: string? name казва на компилатора, че null е допустим, и той ви предупреждава там, където забравяте проверката; стойностен тип става нулируем с ? — int? age = null;.

string е референтен тип, но се държи като стойностен и това често обърква. Низът е неизменяем (immutable): веднъж създаден, съдържанието му не може да се промени. Методите ToUpper(), Replace(), Trim() не пипат низа, а връщат нов — ако не запишете резултата (text = text.ToUpper();), промяната се губи. При string b = a; b += "!"; променливата a остава същата, защото += създава нов низ и пренасочва само b. Освен това за string операторът == е специално предефиниран да сравнява съдържанието, а не адресите, така че "abc" == "abc" е true, както очаквате.

За всеки друг клас обаче == по подразбиране означава „един и същ обект ли е“ (reference equality): два обекта new Point(1, 2) с еднакви полета не са равни чрез ==, защото живеят на различни адреси. Ако ви трябва сравнение по съдържание, сравнете полетата, предефинирайте Equals и GetHashCode или използвайте record, при който равенството е по стойност. При структурите == изобщо не е дефиниран без ваша намеса, но Equals сравнява поле по поле. Накрая, когато стойностен тип се запише в променлива от тип object (object o = 42;), стойността се опакова (boxing) в нов обект в heap-а; обратното разопаковане (unboxing) е явно преобразуване (int)o. Boxing е незабележим в малки програми, но в цикъл с милиони итерации струва време и памет — още една причина да предпочитате конкретни типове и генерични колекции като List<int> пред object.

Златни правила

Стойност се копира, референция се споделя

= при int и struct прави отделно копие; при class, масив и string копира само адреса. Преди да промените обект през втора променлива, попитайте се: един ли е обектът, или два?

`new` означава heap

Всичко, което създавате с new от клас или масив, живее в динамичната памет и остава там, докато някой го сочи. Локалните променливи и стойностите в тях са в стека и изчезват с края на метода.

Проверявай за `null` преди точката

Всяко нещо.Член, при което нещо може да е null, е потенциален NullReferenceException. Инициализирайте референциите или проверявайте с != null, ?. и ??.

Низът не се променя — презаписва се

ToUpper(), Replace(), Trim() връщат нов низ, а старият остава същият. Винаги записвайте резултата: text = text.Trim();.

`==` при клас пита „същият обект ли е“

Два различни обекта с еднакво съдържание не са равни чрез ==. За сравнение по съдържание използвайте Equals, сравнете полетата или направете типа record. Изключение е string, при който == сравнява текста.

Бърз справочник

Стойностни срещу референтни типове

ХарактеристикаСтойностни типовеРеферентни типове
Примериint, double, bool, char, decimal, enum, structclass, масиви (int[]), string, интерфейси, делегати
Какво пази променливатаСамата стойностРеференция (адрес) към обект в heap-а
Къде живеят даннитеВ стека (като локална променлива) или вътре в обекта, който ги съдържаОбектът е в heap-а; референцията е в стека или в друг обект
Присвояване b = aКопира стойността; a и b са независимиКопира адреса; a и b сочат към един обект
Подаване на методМетодът получава копие и не може да промени оригиналаМетодът може да промени съдържанието на обекта, но не и накъде сочи променливата отвън
Може ли да е nullНе (освен нулируем вариант като int?)Да; полетата и елементите на нов масив са null по подразбиране
Стойност по подразбиране0, false, '\0', нулирани полетаnull
== по подразбиранеСравнява стойностите (struct няма == без предефиниране)Сравнява референциите (същият обект ли е); string е изключение
ОсвобождаванеАвтоматично при излизане от методаОт garbage collector, когато никой вече не сочи към обекта

Работа с референции и null

ЗаписКакво правиПримерБележка
new Тип(...)Създава обект в heap-а и връща референция към негоStudent s = new Student();Всяко new е нов, отделен обект
nullРеференция, която не сочи към нищоStudent? s = null;Достъп до член през null хвърля NullReferenceException
x != null / x is nullПроверка дали има обектif (s != null) Console.WriteLine(s.Name);is null работи дори ако == е предефиниран
?.Достъп до член само ако обектът не е nullint? len = s?.Name.Length;Резултатът е null, когато s е null
??Стойност по подразбиране при nullstring n = s?.Name ?? "Непознат";Чете се „ако е null, вземи…“
refПараметърът е псевдоним на променливата на извикващияSwap(ref a, ref b);Пише се и в метода, и при извикването
outКато ref, но методът трябва да присвои стойностint.TryParse(text, out int n);Аргументът не трябва да е инициализиран предварително
(int[])arr.Clone()Плитко копие на масивint[] copy = (int[])arr.Clone();Елементите, които са обекти, остават споделени
object o = 5; / (int)oBoxing / unboxingobject o = 42; int n = (int)o;Unboxing към грешен тип хвърля InvalidCastException

Код за анализ и пренаписване

struct, class и масив: копие или споделяне

Program.cs
using System;

struct PointStruct
{
    public int X;
    public int Y;
}

class PointClass
{
    public int X;
    public int Y;
}

class Program
{
    static void Main()
    {
        // Стойностен тип: присвояването прави копие
        PointStruct s1 = new PointStruct { X = 1, Y = 2 };
        PointStruct s2 = s1;
        s2.X = 100;
        Console.WriteLine($"struct: s1.X = {s1.X}, s2.X = {s2.X}");

        // Референтен тип: присвояването копира само адреса
        PointClass c1 = new PointClass { X = 1, Y = 2 };
        PointClass c2 = c1;
        c2.X = 100;
        Console.WriteLine($"class:  c1.X = {c1.X}, c2.X = {c2.X}");

        // Масивът също е референтен тип
        int[] a = { 1, 2, 3 };
        int[] b = a;
        b[0] = 99;
        Console.WriteLine($"array:  a[0] = {a[0]}, b[0] = {b[0]}");

        // Истинско копие на масив
        int[] c = (int[])a.Clone();
        c[0] = -1;
        Console.WriteLine($"clone:  a[0] = {a[0]}, c[0] = {c[0]}");

        // == при референтни типове пита: същият обект ли е?
        Console.WriteLine($"c1 == c2: {c1 == c2}, a == b: {a == b}, a == c: {a == c}");
    }
}

Какво се случва тук?

  • PointStruct и PointClass имат еднакви полета, но едната е struct (стойностен тип), а другата — class (референтен тип); цялата разлика в поведението идва от тази една дума.
  • PointStruct s2 = s1; копира полетата: s1 и s2 са две отделни стойности в стека, затова s2.X = 100; оставя s1.X равно на 1.
  • PointClass c2 = c1; копира само референцията — обектът е един, в heap-а, и промяната през c2 се вижда и през c1: двете отпечатват 100.
  • Масивът a е референтен тип като всеки клас: int[] b = a; не създава втори масив, затова b[0] = 99; променя и a[0].
  • (int[])a.Clone() създава нов масив със същите елементи; c вече е независим и c[0] = -1; не засяга a. Преобразуването (int[]) е нужно, защото Clone() връща object.
  • Последният ред показва какво сравнява == при референтни типове: c1 == c2 и a == b са True, защото сочат към същия обект, а a == c е False, макар масивите да изглеждат подобни.
  • Очакван изход: s1.X = 1, s2.X = 100, после c1.X = 100, c2.X = 100, a[0] = 99, b[0] = 99, a[0] = 99, c[0] = -1 и накрая True, True, False.

Параметри, ref, null, неизменяем string и boxing

Program.cs
using System;

class Student
{
    public string Name = "";
    public int Points;
}

class Program
{
    static void AddTen(int points)
    {
        points += 10;          // променя само копието
    }

    static void AddTen(ref int points)
    {
        points += 10;          // променя самата променлива на извикващия
    }

    static void AddTen(Student s)
    {
        s.Points += 10;        // променя споделения обект
    }

    static void Replace(Student s)
    {
        s = new Student { Name = "Нов", Points = 0 };   // сменя само локалната референция
    }

    static void Main()
    {
        int n = 5;
        AddTen(n);
        Console.WriteLine($"int по стойност: {n}");
        AddTen(ref n);
        Console.WriteLine($"int с ref: {n}");

        Student ivan = new Student { Name = "Иван", Points = 5 };
        AddTen(ivan);
        Console.WriteLine($"обект: {ivan.Name} има {ivan.Points} точки");
        Replace(ivan);
        Console.WriteLine($"след Replace: {ivan.Name}");

        string text = "здравей";
        string upper = text.ToUpper();
        Console.WriteLine($"string: {text} / {upper}");

        Student? nobody = null;
        if (nobody == null)
        {
            Console.WriteLine("nobody е null, няма да го пипаме");
        }
        Console.WriteLine(nobody?.Name ?? "(няма име)");

        object boxed = n;          // boxing: int отива в heap-а
        int unboxed = (int)boxed;  // unboxing: обратно в стека
        Console.WriteLine($"boxing: {boxed}, unboxing: {unboxed}");
    }
}

Какво се случва тук?

  • Трите метода AddTen са претоварвания с различен вид параметър: int по стойност, ref int и референтен тип Student; компилаторът избира кой да извика според аргумента.
  • AddTen(n) получава копие на числото и points += 10 променя само него — n остава 5. AddTen(ref n) работи със самата променлива n и тя става 15.
  • AddTen(ivan) получава копие на референцията, но обектът е същият, затова s.Points += 10 увеличава точките на Иван до 15.
  • Replace(ivan) присвоява new Student на локалния параметър s; променливата ivan в Main продължава да сочи към стария обект и след извикването името е все още „Иван“.
  • text.ToUpper() не променя text — низът е неизменяем; новият низ се връща и го записваме в upper. Отпечатва се здравей / ЗДРАВЕЙ.
  • Student? nobody = null; обявява референция, която не сочи към нищо; проверката == null и операторите ?. и ?? ни пазят от NullReferenceException — отпечатва се (няма име).
  • object boxed = n; опакова стойността 15 в нов обект в heap-а (boxing), а (int)boxed я разопакова обратно в стека (unboxing). Изходът е boxing: 15, unboxing: 15.

Внимавай! Чести грешки

Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.

Масивът не се копира с `=`

Грешно

int[] scores = { 90, 80, 70 };
int[] backup = scores;
scores[0] = 0;
// backup[0] също е 0 - резервното копие е изгубено

Правилно

int[] scores = { 90, 80, 70 };
int[] backup = (int[])scores.Clone();
scores[0] = 0;
// backup[0] остава 90

backup = scores копира само референцията — двете имена сочат към един масив. Копие на съдържанието се прави само изрично с Clone(), Array.Copy или нов масив.

Член през `null`

Грешно

string[] names = new string[3];
Console.WriteLine(names[0].Length);   // NullReferenceException

Правилно

string[] names = new string[3];
int length = names[0]?.Length ?? 0;
Console.WriteLine(length);            // 0 вместо срив

Новият масив от референтен тип е пълен с null, а null няма Length. Проверете за null с if, или използвайте ?. и ??, за да дадете стойност по подразбиране.

Забравен резултат от `ToUpper()`

Грешно

string name = "иван";
name.ToUpper();
Console.WriteLine(name);   // иван

Правилно

string name = "иван";
name = name.ToUpper();
Console.WriteLine(name);   // ИВАН

Низовете са неизменяеми: ToUpper() не променя name, а връща нов низ. Без присвояване новият низ веднага се губи.

Сравнение на обекти с `==`

Грешно

Point a = new Point { X = 1, Y = 2 };
Point b = new Point { X = 1, Y = 2 };
Console.WriteLine(a == b);   // False - два различни обекта

class Point { public int X; public int Y; }

Правилно

Point a = new Point(1, 2);
Point b = new Point(1, 2);
Console.WriteLine(a == b);   // True - равенство по стойност

record Point(int X, int Y);

За класове == проверява дали двете променливи сочат към един и същ обект. Ако ви трябва равенство по съдържание, сравнете полетата, предефинирайте Equals и GetHashCode, или обявете типа като record.

Задачи за самостоятелна работа

Опитай първо сам — подсказката е там само ако наистина закъсаш.

Структура или клас?

Дефинирайте структура RectStruct и клас RectClass, всеки с полета Width и Height. В Main създайте по един правоъгълник от всеки тип със страни 2 и 3, присвоете го на втора променлива, променете Width на копието на 10 и отпечатайте размерите на оригинала и на копието. Преди да пуснете програмата, запишете какво очаквате да видите, и после сравнете.

Какво може да промени методът

Напишете три метода: Swap(ref int a, ref int b), който разменя две променливи; FillZeros(int[] arr), който нулира всички елементи на масива; и TryReplace(int[] arr), който присвоява на параметъра нов масив { 7, 7, 7 }. В Main ги извикайте върху int x = 1, y = 2 и масив { 5, 6, 7 } и отпечатайте резултата след всяко извикване. Обяснете с коментар защо TryReplace не променя масива на извикващия, а FillZeros го променя.

Безопасно сравнение на книги

Създайте клас Book с полета Title и Author. Напишете метод static bool SameBook(Book? a, Book? b), който връща true, ако двете референции сочат към един и същ обект или ако заглавието и авторът съвпадат, и false в останалите случаи — без да хвърля изключение, когато една от двете (или и двете) е null. Проверете го с: обект и негов псевдоним, два отделни обекта с еднакво съдържание, различна книга и null. Отпечатайте и резултата от == за първите два случая, за да видите разликата.

Мини-тест за проверка

Отговори си наум (или на глас!) и чак тогава разкрий отговора.

1. След `int[] a = { 1, 2, 3 }; int[] b = a; b[1] = 0;` какво ще отпечата `Console.WriteLine(a[1]);` и защо?

2. Методът `static void Change(int x) { x = 10; }` е извикан с `int n = 3; Change(n);`. Каква е стойността на `n` след това и как да накарате метода наистина да я промени?

3. Какво ще се случи при `Student? s = null; Console.WriteLine(s.Name);` и как се предпазваме?

4. Защо `p1 == p2` връща `false` за два обекта `new Point { X = 1, Y = 1 }` от клас `Point`, а `"ab" == "ab"` връща `true`?

Речник на термините

Виж пълния речник на курса
Стек (stack)
Област от паметта, в която живеят локалните променливи и параметрите на всеки изпълняващ се метод. Освобождава се автоматично, когато методът приключи.
Динамична памет (heap)
Област, в която с new се създават обектите от референтни типове. Обектът живее, докато някой го сочи; след това го освобождава събирачът на боклук (garbage collector).
Стойностен тип (value type)
Тип, чиято променлива съдържа самата стойност — int, double, bool, enum, struct. Присвояването и подаването на метод правят копие.
Референтен тип (reference type)
Тип, чиято променлива съдържа адрес към обект в heap-а — class, масиви, string. Присвояването споделя обекта, а не го копира.
Референция (reference)
Адресът, по който се намира един обект; „стрелката“ от променливата към обекта. Няколко референции могат да сочат към един и същ обект.
`null`
Специална стойност на референция, която не сочи към нищо. Стойностните типове не могат да са null, освен ако са обявени като нулируеми (int?).
`NullReferenceException`
Изключение, което се хвърля при опит за достъп до член (поле, метод, индекс) през референция със стойност null.
Неизменяем (immutable)
Обект, чието съдържание не може да се промени след създаването му. string е неизменяем: всяка „промяна“ създава нов низ.
Boxing / unboxing
Опаковане на стойностен тип в обект от тип object в heap-а (object o = 5;) и обратното явно преобразуване ((int)o). Струва време и памет, затова се избягва в горещи цикли.

Провери знанията

Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.

Провери знанията си

9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.

Препоръки за този модул

  • Рисувайте паметта на хартия: отляво стекът с променливите, отдясно heap-ът с обектите, а референциите — като стрелки. Щом две стрелки сочат към една кутия, промяната през едната се вижда и през другата.
  • Когато получите неочаквана промяна на масив или обект, потърсете мястото, където сте написали = между две променливи от референтен тип — почти винаги сте споделили, а не копирали.
  • Четете съобщението на NullReferenceException докрай: дебъгерът спира точно на реда с грешката. Поставете breakpoint на този ред и вижте коя променлива е null, вместо да гадаете.
  • Експериментирайте с малки програми: напишете един и същ тип веднъж като struct и веднъж като class, копирайте, променете и отпечатайте. Пет минути опит се помнят по-дълго от правило наизуст.

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.