Kakšna je razlika med vrednostnimi in referenčnimi tipi?

Question

Accepted Answer

C# tipi spadajo v dve temeljni kategoriji: **vrednostni tipi** (shranjevanje podatkov neposredno) in **referenčni tipi** (shranjevanje reference/kazalca na podatke v heap-u). Razlikujejo se v tem, kako se shranjujejo, kopirajo in primerjajo — to je bistvena razlika, ki vpliva na obnašanje v celotnem jeziku.

## Dve kategoriji

```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.
```

## Ključna razlika: semantika kopiranja

```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!
```

Pripisovanje vrednostnega tipa kopira podatke (neodvisno); pripisovanje referenčnega tipa kopira referenco (oba imena kažeta na isti predmet, zato mutacija prek enega vpliva na drugega).

## Primerjava in prosljeđivanje metodam

```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>).
```

## Zakaj je to pomembno

Razlika med vrednostnim in referenčnim tipom je eden od najbolj temeljnih konceptov v C#-u in pojasnjuje širok spekter obnašanja in napak — zato je to nujno potrebno znanje.

Razumevanje, da so **vrednostni tipi** (strukture, primitivni tipi kot int/double, enumeracije) kopirani po vrednosti (neodvisne kopije), medtem ko so **referenčni tipi** (razredi, polja, nizi) kopirani po referenci (oba imena kažeta na isti predmet), je ključno za napovedovanje obnašanja podatkov: sprememba kopije vrednostnega tipa ne vpliva na original, toda mutacija deljenih referenčnih objektov vpliva na vse reference nanj (pogost vir presenetljivih napak).

Ta razlika vpliva tudi na **enakost** (`==` primerja vrednosti za vrednostne tipe, vendar identiteto reference za referenčne tipe po privzetku), **argumente metod** (vrednostni tipi se prosljeđujejo kot kopije, reference referenčnih tipov se prosljeđujejo po vrednosti — zato lahko metode mutirano prosljeđeni predmet, vendar ne prosljeđenega int-a) in **ničelnost** (samo referenčni tipi so lahko null, razen če je vrednostni tip narejen ničljiv z `?`).

Razumevanje, kateri tipi so vrednostni in kateri referenčni ter posledična semantika kopiranja, primerjave in mutacije je temeljno za pisanje pravilnega C#-a in izogibanju najbolj pogostim konceptualnim pastim jezika — to podpira, kako podatki tečejo skozi program, in je pogosta tema na intervjujih ravno zato, ker razkrije, ali razvijalec res razume C#-ov tipski sistem.