„C Sharp programozás/Operátorok” változatai közötti eltérés

Tartalom törölve Tartalom hozzáadva
→‎Relációs operátorok: +relációs operátorok táblázat
Nincs szerkesztési összefoglaló
299. sor:
}
</source>
 
=== Bit operátorok ===
 
Az előző fejezetben említett logikai operátorok bitenkénti műveletek elvégzésére is alkalmasak numerikus típusokon.
A számítógép az adatokat kettes számrendszer –beli alakban tárolja, így pl. ha van egy byte típusú változónk (ami egy byte azaz 8 bit hosszú) aminek a „2” értéket adjuk, akkor az a következőképpen jelenik meg a memóriában:
 
<source lang="csharp">
2 -> 00000010
</source>
 
A bit operátorok ezzel a formával dolgoznak.
Az eddig megismert kettő mellé még jön négy másik operátor is. A műveletek:
 
Bitenkénti „és”: veszi a két operandus bináris alakját és a megfelelő bitpárokon elvégzi az „és” műveletet azaz ha mindkét bit 1 állásban van akkor az adott helyen az eredményben is az lesz, egyébként 0:
 
<source lang="csharp">
01101101
00010001 AND
00000001
</source>
 
Példa:
 
<source lang="csharp">
using System;
 
class Program
{
static public void Main()
{
int x = 10;
Console.WriteLine(x & 2);
//1010 & 0010 = 0010 = 2
Console.ReadKey();
}
}
</source>
 
Bitenkénti „vagy”: hasonlóan működik mint az „és”, de a végeredményben egy bit értéke akkor lesz 1, ha a két operandus adott bitje közül az egyik is az:
 
<source lang="csharp">
01101101
00010001 OR
01111101
</source>
 
<source lang="csharp">
using System;
 
class Program
{
static public void Main()
{
int x = 10;
Console.WriteLine(x | 2);
//1010 | 0010 = 1010 = 10
Console.ReadKey();
}
}
</source>
 
Biteltolás balra: a kettes számrendszerbeli alak „felső” bitjét eltoljuk és a jobb oldalon keletkező üres bitet nullára állítjuk. Az operátor: <<:
 
<source lang="csharp">
10001111 LEFT SHIFT
100011110
</source>
 
<source lang="csharp">
using System;
 
class Program
{
static public void Main()
{
int x = 143;
Console.WriteLine(x << 1);
//10001111 (=143) << 1 = 100011110 = 286
Console.ReadKey();
}
}
</source>
 
Biteltolás jobbra: most az alsó bitet toljuk el és felül pótoljuk a hiányt. Az operátor: >>:
 
<source lang="csharp">
using System;
 
class Program
{
static public void Main()
{
int x = 143;
Console.WriteLine(x >> 1);
Console.ReadKey();
}
}
</source>
 
=== Rövid forma ===
 
Vegyük a következő példát:
 
<source lang="csharp">
x = x + 10;
</source>
 
Az x nevű változót megnöveltük tízzel. Csakhogy van egy kis baj: ez a megoldás nem túl hatékony. Mi történik valójában? Elsőként értelmezni kell a jobb oldalt, azaz ki kell értékelni x –et, hozzá kell adni tízet és eltárolni a veremben. Ezután ismét kiértékeljük x –et, ezúttal a bal oldalon.
Szerencsére van megoldás, mégpedig az ún. rövid forma. A fenti sorból ez lesz:
 
<source lang="csharp">
x += 10;
</source>
 
Rövidebb, szebb és hatékonyabb. Az összes aritmetikai operátornak létezik rövid formája.
 
A probléma ugyanaz, de a megoldás más a következő esetben:
 
<source lang="csharp">
x = x + 1;
</source>
 
Szemmel láthatóan ugyanaz a baj, azonban az eggyel való növelésre-csökkentésre van önálló operátorunk:
 
<source lang="csharp">
++x/--x;
x++/x--;
</source>
 
Ebből az operátorból rögtön két verziót is kapunk, prefixes (++/-- elől) és postfixes formát. A prefixes alak pontosan azt teszi amit elvárunk tőle, azaz megnöveli(csökkenti) az operandusát egyel.
A postfixes forma egy kicsit bonyolultabb, elsőként létrehoz egy átmeneti változót, amiben eltárolja az operandusa értékét, majd megnöveli eggyel az operandust, végül visszaadja az átmeneti változót. Ez elsőre talán nem tűnik hasznosnak, de vannak helyzetek amikor lényegesen megkönnyíti az életünket a használa.
Attól függően, hogy növeljük vagy csökkentjük az operandust inkrementális illetve dekrementáló operátorról beszélünk.
 
=== Egyéb operátorok ===
 
Unáris -/+: az adott szám pozitív illetve negatív értékét jelezzük vele. Csakis előjeles típusokon működik.
 
Typeof: az operandusa típusát adja vissza:
 
<source lang="csharp">
using System;
 
class Program
{
static public void Main()
{
int x = 143;
if(typeof(int) == x.GetType())
{
Console.WriteLine("X tipusa int");
}
Console.ReadKey();
}
}
</source>
 
A változón meghívott GetType() metódus (amit mellesleg minden típus a System.Object –től örököl) a változó típusát adja vissza.