Koja je razlika između value i reference tipova?

Question

Accepted Answer

C# tipovi se dijele u dvije temeljne kategorije: **value tipovi** (direktno pohranjuju podatke) i **reference tipovi** (pohranjuju referencu/pokazivač na podatke na heap-u). Razlikuju se po tome kako se pohranjuju, kopiraju i uspoređuju — što je kritična distinkcija koja utječe na ponašanje kroz cijeli jezik.

## Dvije kategorije

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

Dodjela value tipa kopira podatke (nezavisno); dodjela reference tipa kopira referencu (oba imena pokazuju na isti objekt, pa mutacija kroz jedno utječe na drugo).

## Usporedba i prolazak metodama

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

## Zašto je to važno

Distinkcija value-vs-reference je jedan od najtemeljnijih koncepata u C#-u, i objašnjava širok raspon ponašanja i grešaka — što je esencijalno znanje.

Razumijevanje da su **value tipovi** (structs, primitivni tipovi kao int/double, enumi) kopirani po vrijednosti (nezavisne kopije), dok su **reference tipovi** (klase, nizovi, stringovi) kopirani po referenci (oba imena pokazuju na isti objekt) je ključno za predviđanje kako se podaci ponašaju: mijenjanje value-type kopije ne utječe na original, ali mutacija dijeljenog reference-type objekta utječe na sve reference na njega (česti izvor iznenađujućih grešaka).

Ova distinkcija također utječe na **jednakost** (`==` uspoređuje vrijednosti za value tipove, ali identitet reference za reference tipove po zadanom), **argumente metode** (value tipovi proslijeđeni kao kopije, reference reference tipova proslijeđene po vrijednosti — pa metode mogu mutirati proslijeđeni objekt ali ne proslijeđeni int), i **null-omogućenost** (samo reference tipovi mogu biti null, osim ako value tip nije učinjen nullable s `?`).

Razumijevanje koji su tipovi value nasuprot reference i rezultirajuća semantika kopiranja, usporedbe i mutacije je temeljno za pisanje ispravnog C#-a i izbjegavanja najčešćih konceptualnih zamki jezika — temelji kako podaci prolaze kroz program i često je tema razgovora za posao upravo jer otkriva razumije li razvojni inženjer stvarno C#-ov sustav tipova.