Cad é an difríochtaí idir cineálacha luachanna agus cineálacha tagartha?

Question

Accepted Answer

Tagann cineálacha C# faoi dhá chatagóir bhunúsacha: **cineálacha luachanna** (stóráil an sonraí go díreach) agus **cineálacha tagartha** (stóráil tagairt/pointéir ar shonraí ar an gcarn). Bíonn siad difriúil maidir le conas a stóráiltear iad, conas a chóipeáiltear iad, agus conas a dhéantar comparáid orthu — idirdhealú ríthábhachtach a dhéanann difear do iompar ar fud an teanga.

## An dá chatagóir

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

## An príomhdhifríochtaí: sémantaic chóipeála

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

Nuair a dhéanann tú cineál luachanna a shannadh, cóipeáltar an sonraí (neamhspleách); nuair a dhéanann tú cineál tagartha a shannadh, cóipeáltar an tagairt (pointeálann an dá ainm ar an réad céanna, agus mar sin beidh droch-iompar trí cheann ar an bhfíoránach).

## Comparáid agus seoladh chuig modhanna

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

## Cén fáth a bhí an tábhacht air

Tá an idirdhealú idir luach agus tagairt ar cheann de na coincheapa is bunúsaí i C#, agus míníonn sé raon leathan iompar agus fabhtanna — agus dá bhrí sin is gá a bheith ar eolas air.

Tá sé fíor-riachtanach a thuiscint go bhfuil **cineálacha luachanna** (struchtúir, primitives cosúil le int/double, enums) cóipeáilte de réir luach (cóipeanna neamhspleácha) agus go bhfuil **cineálacha tagartha** (ranganna, eagáin, teaghráin) cóipeáilte de réir tagairt (an dá ainm ag pointáil ar an réad céanna) chun a thuiscint conas a iompar sonraí: ní dhéanann cóip cineál luachanna a mhionathrú an bunúsach a bhualadh, ach beidh droch-iompar ar réad cineál tagartha a dhéantar a roinnt a dhéanann difear do gach tagairt air (foinse choitianta gabhdála iontach).

Bíonn an idirdhealú seo ag déanamh difir freisin do **comhionannas** (`==` déanann comparáid ar luachanna do chineálacha luachanna ach ar aitheantas tagartha do chineálacha tagartha go réamhshocraithe), **argóintí modh** (cineálacha luachanna a sheoltar mar chóipeanna, tagairt chineálacha tagartha a bheith seolta de réir luach — agus mar sin is féidir le modhanna réad seolta a mhionathrú ach ní int seolta), agus **nullability** (ní féidir ach cineálacha tagartha a bheith null, mura ndéantar cineál luachanna a dhéanamh nullable le `?`).

Tá an tuiscint ar chineálacha idir luach agus tagairt agus an sémantaic chóipeála, comparáide, agus iompar a bhíonn mar bhun ar bhunchur C# agus ar dhiúltú do ghealltanais coincheapúla an teanga — cuireann sé tús ar conas a fholuain sonraí trí chlár agus tá sé ar thóp a bhíonn go minic i gceisneachán toisc gur léiriú ar cibé an bhfuil eolas fíor ag forbróir ar chóras cineálacha C#.