„C Sharp programozás/Operátorok” változatai közötti eltérés
Tartalom törölve Tartalom hozzáadva
Új oldal, tartalma: „Amikor programozunk utasításokat adunk a számítógépnek. Ezek az utasítások kifejezésekből állnak, a kifejezések pedig operátorokból és operandusokból ille...” |
Nincs szerkesztési összefoglaló |
||
76. sor:
Console.WriteLine(z); // Az osztás maradékát írja ki: 1
Console.ReadKey(); //Vár egy billentyűleütést
}
}
</source>
=== Relációs operátorok ===
A relációs operátorok segítségével egy adott értékészlet elemei közti viszonyt tudjuk lekérdezni. A numerikus típusokon értelmezve van egy rendezés reláció:
<source lang="csharp">
using System;
public class RelOp
{
static public void Main()
{
int x = 10;
int y = 23;
Console.WriteLine(x > y); //Kiírja az eredményt: false
Console.WriteLine(x == y); //false
Console.WriteLine(x != y); //x nem egyenlő y –al: true
Console.WriteLine(x <= y); //x kisebb-egyenlő mint y: true
Console.ReadKey();
}
}
</source>
Az első sor egyértelmű, a másodikban az egyenlőséget vizsgáljuk a kettős egyenlőségjellel. Ilyen esetekben figyelni kell, mert egy elütés is nehezen kideríthető hibát okoz, amikor egyenlőség helyett az értékadó operátort használjuk. Az esetek többségében ugyanis így is le fog fordulni a program, működni viszont valószínűleg rosszul fog.
Minden ilyen operátor logikai típussal tér vissza. A relációs operátorok összefoglalása:
=== Logikai/feltételes operátorok ===
Akárcsak a C++, a C# sem rendelkezik „igazi” logikai típussal, ehelyett 1 és 0 jelzi az igaz és hamis értékeket:
<source lang="csharp">
using System;
public class RelOp
{
static public void Main()
{
bool l = true;
bool k = false;
if(l == true && k == false)
{
Console.WriteLine("Igaz");
}
Console.ReadKey();
}
}
</source>
Először felvettünk két logikai (bool) változót, az elsőnek „igaz” a másodiknak „hamis” értéket adtunk. Ezután egy elágazás következik, erről bővebben egy későbbi fejezetben lehet olvasni, a lényege az, hogy ha a feltétel igaz, akkor végrehajt egy bizonyos utasítás(oka)t. A fenti példában az „és” (&&) operátort használtuk, ez két operandust vár és akkor ad vissza „igaz” értéket, ha mindkét operandusa „igaz” vagy nullánál nagyobb értéket képvisel. Ebből következik az is, hogy akár az előzö fejezetben megismert relációs operátorokból felépített kifejezések, vagy matematikai formulák is lehetnek operandusok. A program maga kiírja, hogy „Igaz”.
Nézzük az „és” igazságtáblázatát:
A második operátor a „vagy”:
<source lang="csharp">
using System;
public class RelOp
{
static public void Main()
{
bool l = true;
bool k = false;
if(l == true || k == true)
{
Console.WriteLine("Igaz");
}
Console.ReadKey();
}
}
</source>
A „vagy” (||) operátor akkor térít vissza „igaz” értéket, ha az operandusai közül valamelyik „igaz” vagy nagyobb mint nulla. Ez a program is ugyanazt csinálja, mint az előző, a különbség a feltételben van, „k” biztosan nem „igaz” (hiszen épp előtte kapott „hamis” értéket).
A „vagy” igazságtáblázata:
Az eredmény kiértékelése az ún. „lusta kiértékelés” (vagy „rövidzár”) módszerével történik, azaz a program csak addig vizsgálja a feltételt amíg muszáj. Pl. a „vagy” példában a „k” soha nem fog kiértékelődni, mivel „l” van az első helyen (balról jobbra haladunk) és ő „igaz”, vagyis a feltétel „k” értékétől függetlenül mindenképpen teljesül.
A harmadik a „tagadás” (!()):
<source lang="csharp">
using System;
public class RelOp
{
static public void Main()
{
int x = 10;
if(!(x == 11))
{
Console.WriteLine("X nem egyenlo 11 -el!");
}
Console.ReadKey();
}
}
</source>
Ennek az operátornak egy operandusa van, akkor ad vissza igaz értéket, ha az operandusban megfogalmazott feltétel hamis vagy egyenlő nullával. A „tagadás” (negáció) igazságtáblája:
Ez a három operátor ún. feltételes operátor, közölük az „és” és „vagy” operátoroknak létezik a „csonkolt” logikai párja is. A különbség annyi, hogy a logikai operátorok az eredménytől függetlenül kiértékelik a teljes kifejezést, nem élnek a „lusta” kiértékeléssel. A logikai „vagy” művelet:
<source lang="csharp">
if(l == true | k == true)
{
Console.WriteLine("Igaz");
}
</source>
A logikai „és”:
<source lang="csharp">
if(l == true & k == true)
{
Console.WriteLine("Igaz");
}
</source>
A logikai operátorok családjához tartozik (ha nem is szorosan) a feltételes operátor. Ez az egyetlen háromoperandusu operátor, a következőképpen működik:
feltétel ? igaz-ág : hamis-ág;
<source lang="csharp">
using System;
public class RelOp
{
static public void Main()
{
int x = 10;
int y = 10;
Console.WriteLine( (x == y) ? "Egyenlo" : "Nem egyenlo");
Console.ReadKey();
}
}
| |||