Jaký je rozdíl mezi hodnotovými a referenčními typy?

Question

Accepted Answer

Typy v C# se dělí na dvě základní kategorie: **hodnotové typy** (ukládají data přímo) a **referenční typy** (ukládají referenci/ukazatel na data na haldě). Liší se v tom, jak jsou ukládány, kopírovány a porovnávány — jedná se o zásadní rozdíl, který ovlivňuje chování v celém jazyce.

## Dvě kategorie

```text
Value types     → struct, int, double, bool, char, enum, DateTime, decimal
                  Stored INLINE (stack for locals); copied BY VALUE.
Reference types → class, string, array, object, interface, delegate
                  Variable holds a REFERENCE to data on the heap; copied BY REFERENCE.
```

## Klíčový rozdíl: sémantika kopírování

```csharp
// VALUE type — assignment COPIES the value (independent)
int a = 5;
int b = a;      // b is a COPY
b = 10;         // a is still 5

struct Point { public int X; }
Point p1 = new() { X = 1 };
Point p2 = p1;  // COPIES the whole struct
p2.X = 99;      // p1.X is still 1

// REFERENCE type — assignment copies the REFERENCE (both point to the SAME object)
class Box { public int Value; }
Box box1 = new() { Value = 1 };
Box box2 = box1;   // both reference the SAME Box
box2.Value = 99;   // box1.Value is now 99 too!
```

Přiřazení hodnotového typu kopíruje data (nezávisle); přiřazení referenčního typu kopíruje referenci (obě jména ukazují na stejný objekt, takže mutace přes jedno ovlivňuje to druhé).

## Porovnání a předávání metodám

```csharp
// == compares VALUES for value types, REFERENCES (identity) for reference types
string s1 = "hi"; // (string is special — == compares content)
Box b1 = new(), b2 = new();
b1 == b2;   // false — different objects (reference equality by default)

// methods get a COPY of value types, the reference (by value) for reference types
void Modify(Box b) { b.Value = 100; }   // affects the caller's object
void Modify(int x) { x = 100; }           // does NOT affect the caller's int
```

## null

```text
Reference types can be null (no object). Value types CANNOT be null
(unless made nullable: int? — a Nullable<int>).
```

## Proč je to důležité

Rozdíl mezi hodnotovými a referenčními typy je jedním z nejzákladnějších konceptů v C#, a vysvětluje širokou škálu chování a chyb — což z něj činí nezbytné znalosti.

Pochopení toho, že **hodnotové typy** (struktury, primitiva jako int/double, výčty) se kopírují podle hodnoty (nezávislé kopie), zatímco **referenční typy** (třídy, pole, řetězce) se kopírují podle reference (obě jména ukazují na stejný objekt), je rozhodující pro předpovídání chování dat: úprava kopie hodnotového typu neovlivňuje originál, ale mutace sdíleného objektu referenčního typu ovlivňuje všechny reference na něj (běžný zdroj překvapivých chyb).

Tento rozdíl také ovlivňuje **porovnání** (`==` porovnává hodnoty u hodnotových typů, ale identitu reference u referenčních typů ve výchozím nastavení), **argumenty metod** (hodnotové typy předávány jako kopie, reference referenčních typů předávány podle hodnoty — takže metody mohou mutovat předaný objekt, ale ne předané int), a **nullovatelnost** (pouze referenční typy mohou být null, pokud není hodnotový typ učiněn nullovatelným pomocí `?`).

Pochopení toho, které typy jsou hodnotové vs. referenční, a výsledná sémantika kopírování, porovnání a mutace, je základem pro psaní správného C# a vyhýbání se nejčastějším koncepčním úskalím jazyka — je to základ toho, jak data proudí programem, a je to oblíbené téma v pohovorech právě proto, že odhaluje, zda vývojář skutečně rozumí typovému systému C#.