Poznáváme C# a Microsoft.NET – 8. díl

V tomto díle se zaměříme na použití příkazů pro větvení toku programu, které nám jsou v jazyku C# k dispozici. Spolu s tím se něco dozvíme o relačních a logických operátorech, které jsou s jejich užíváním spojeny a také o přetěžování operátorů pro konkrétní třídy.

Relační operátory

Relační operátory využijeme v případech, kdy potřebujeme porovnat nějaké dvě hodnoty. Všechny operace, prováděné použitím relačních operátorů, mají výsledek logického typu bool. Typ bool může nabývat pouze dvou hodnot a to true (pravda) nebo false (nepravda).

Jazyk C# definuje následující relační operátory:

Operace Výsledek
a == b true, pokud se hodnota a rovná hodnotě b
a != b true, pokud se hodnota a nerovná hodnotě b
a < b true, pokud hodnota a je menší než hodnota b
a <= b true, pokud hodnota a je menší než hodnota b, nebo je rovna hodnotě b
a > b true, pokud hodnota a je větší než hodnota b
a >= b true, pokud hodnota a je vetší než hodnota b, nebo je rovna hodnotě b

Výsledek operace můžeme znegovat použitím operátoru logické negace, který je v jazyku C# představován vykřičníkem (!). Negace znamená, že z hodnoty true se stane false a naopak. Následující příklad demonstruje možné použití operátoru logické negace.

bool pokus = !(3 > 2); //vrati false

Operátor == u odkazových typů, pokud ho daná třída nepřetěžuje , vrací true v případě, že se jedná o tentýž objekt a neporovnává jestli mají objekty stejnou hodnotu, jak se tomu děje v případě hodnotových typů. Pokud třída operátor přetěžuje, kompilátor použije jeho implementaci pro danou třídu.

Logické operátory

Logické operátory se používají k provádění logických nebo bitových operací nad hodnotami.

Jazyk C# definuje následující logické operátory:

Operátor Popis
& bitový součin obou operandů
| bitový součet obou operandů
^ bitový výlučný součet obou operandů (XOR)
&& logický součin dvou operandů
|| logický součet dvou operandů

Operátor && se hodí, pokud potřebuje otestovat, zda oba výrazy splňují podmínku.

int a = 2;
int b = 3;
int c = 4;
int d = 5;
bool vysledek = ( (a < b) && (d > c) ); //vysledek je true
bool vysledek2 =( (a > b) && (d > c) ); //vysledek je false

Operátor || využijeme pokud mám stačí, že alespoň jeden výraz ze dvojice splňuje podmínku.

Tím pádem, kdybychom v předchozím příkladu místo operátoru && použili operátor ||, oba výsledky by nabývali hodnoty true.

bool vysledek2 =( (a > b) || (d > c) ); //vysledek je true

Operátory && a || se od svých jednoznakových verzí liší také tím, že provádějí takzvané zkrácené vyhodnocování mezi výrazy. To znamená, že ve výrazu:

a && b

bude výraz b vyhodnocen pouze v případě, že je splněn výraz a. A ve výrazu:

a || b

bude výraz b vyhodnocen pouze pokud výraz a není splněn.

Podmínkové příkazy

Podmínkové příkazy se používají pro vykonání nějakých operací na základě hodnoty nějakého výrazu. Pro podmíněné vykonání operací slouží v jazyku C# příkazy if a switch.

Příkaz if

Podmínkový příkaz if je jeden z nejpoužívanějších příkazů. Jazyk C# disponuje možností jej použít jak v neúplné podmínce, kde je použito pouze klíčové slovo if, tak v úplné podmínce s použitím klíčových slov if a else. Parametrem příkazu if je booleovský výraz a pokud je tento výraz splňen jsou provedeny požadované operace. Syntaxe je:

if (booleovský výraz)
{
  příkazy, které jsou provedeny pouze je li podmínka splněna
}

Pokud má být za splněné podmínky vykonán pouze jeden příkaz, nejsou složené závorky nutné. Chceme-li zapsat úplnou podmínku, zápis bude vypadat následovně:

if (booleovský výraz)
{
  příkazy, které jsou provedeny pouze je li podmínka splňena
}
else
{
  příkazy, které jsou provedeny pouze není li podmínka splňena
}

Následující jednoduchý příklad demonstruje použití příkazu if.

if (a == 1)
{
  Console.WriteLine("Hodnota je rovna 1");
}
else
{
  Console.WriteLine("Hodnota neni rovna 1");
}

V případě, že potřebujeme definovat odlišné chování pro více hodnot výrazu, než jen jednu, můžeme využít příkazu else if, jak je znázorněno níže.

if (a == 1)
{
  //prikazy, ktere budou provedeny pokud hodnota
  //promenne a je rovna 1
}
else if(a == 2)
{
  //prikazy, ktere budou provedeny pokud hodnota
  //promenne a je rovna 2
}
else
{
  //prikazy, ktere budou provedeny, pokud hodnota
  //promenne a neni rovna ani 1 ani 2
}

Ternární operátor

Pomocí ternárního operátoru je nám umožněno v jazyku C# zapsat podmíněný výraz. Ternární operátor můžeme chápat jako zjednodušený zápis pro if-else, ale s tím rozdílem, že se jedná o výraz a nikoli příkaz jako je tomu u zmíněného if-else. Tím pádem je použití ternárního operátoru v některých situacích vhodnější. Syntaxe vypadá takto:

identifikátor = (booleovský výraz) ? výraz_při_splnění : výraz_při_nesplnění;

Takže použití může vypadat následovně:

int i = 4;
//promenna stav nabude hodnoty "Je mensi"
string stav = (i < 5) ? "Je mensi" : "Je vetsi nebo rovno";

Příkaz switch

Switch je příkaz pro mnohonásobné větvení programu. Když chceme definovat chování pro větší počet hodnot výrazu, je příkaz switch vhodnější než použití odpovídající posloupnosti příkazů if. V příkazu switch jsou jednotlivé větve pro hodnoty výrazu definovány pomocí klíčového slova case. Každá větev musí být ukončena příkazem break nebo goto. Příkaz break definitivně ukončí provádění příkazu switch a příkaz goto umožňuje skok na jiný blok case uvnitř příkazu switch. Také je možné použít větev default, která je provedena, když žádná z definovaných větví case nevyhovuje. Zápis je následující:

switch (výraz)
{
  case hodnota_1 :
    prikazy pro hodnotu 1
    break;
...
  case hodnota_n :
    prikazy pro hodnotu n
    break;
  default :
    prikazy pro ostatni hodnoty
    break;
}

Výraz podle kterého je rozhodováno musí být číselného typu nebo typu char a nebo typu string. Možné použití demostruje tento příklad:

switch (a)
{
  case 1:
  case 2:
    //tento blok zpracovava hodnoty 1 i 2
    Console.WriteLine("Hodnota je 1 nebo 2");
    break;
  case 3:
    Console.WriteLine("Hodnota je 3");
    break;
  case 4:
    Console.WriteLine("Střední číslo");
    //prikaz goto provede skok do vetve
    //pro hodnotu 3
    goto case 3;
  default:
    Console.WriteLine("Jina hodnota");
    break;
}

Přetěžování operátorů

V jazyku C# je umožněno přetěžování operátorů, jehož prostřednictvím lze definovat novou funkčnost operátorů nad třídami, takže je možné určité funkce zapisovat pomocí operátorů. Přetěžování operátorů je vhodné použít u takových datových typů u kterých je zřejmé, co daný operátor provádí. Výsledkem přetěžování operátorů je možnost pozdějšího úsporného vyjádření. Ne všechny operátory je možné ve třídě přetížit. Lze přetížit pouze některé unární, bitové nebo relační operátory.

Operátor se ve třídě definuje použitím klíčového slova operator. Definice operátoru ve třídě musí být vždy označena jako statická mít specifikátor přístupu public.

Následující třída představující komplexní číslo implementuje některé přetížitelné operátory.

public class KomplexniCislo
{
  private int realnaCast;
  private int imaginarniCast;
  public KomplexniCislo(int aRealnaCast, int aImaginarniCast)
  {
    realnaCast = aRealnaCast;
    imaginarniCast = aImaginarniCast;
  }
  public int RealnaCast
  {
    get{return realnaCast;}
    set{realnaCast = value;}
  }
  public int ImaginarniCast
  {
    get{return imaginarniCast;}
    set{imaginarniCast = value;}
  }
  //definice operatoru pro scitani dvou komplexnich cisel
  public static KomplexniCislo operator + (KomplexniCislo komplexni1, KomplexniCislo komplexni2)
  {
    int lNovaRealnaCast = komplexni1.realnaCast + komplexni2.realnaCast;
    int lNovaImaginarniCast = komplexni1.imaginarniCast + komplexni2.imaginarniCast;
    return new KomplexniCislo(lNovaRealnaCast,lNovaImaginarniCast);
  }
  //definice operatoru ekvivalence
  public static bool operator == (KomplexniCislo komplexni1, KomplexniCislo komplexni2)
  {
    return komplexni1.realnaCast == komplexni2.realnaCast && komplexni1.imaginarniCast == komplexni2.imaginarniCast;
  }
  //definice operatoru non-ekvivalence
  public static bool operator != (KomplexniCislo komplexni1, KomplexniCislo komplexni2)
  {
    return komplexni1.realnaCast != komplexni2.realnaCast && komplexni1.imaginarniCast != komplexni2.imaginarniCast;
  }
  //prekryti metody ToString tridy object
  public override string ToString()
  {
    return (String.Format("{0} {1}i",realnaCast,imaginarniCast));
  }
}

Později je možné přetížené operátory použít při práci s instancemi třídy KomplexniCislo, jak demonstruje následující příklad.

KomplexniCislo lKomplexniCislo1 = new KomplexniCislo(4,4);
KomplexniCislo lKomplexniCislo2 = new KomplexniCislo(3,2);
KomplexniCislo lSoucet = lKomplexniCislo1 + lKomplexniCislo2;
Console.WriteLine("Soucet : " + lSoucet);
Console.WriteLine("Ekvivalence : " + (lKomplexniCislo1 == KomplexniCislo2));

Poznámka: Při přetěžování relačních operátorů, musí být nová implementace uskutečněna v párech. To znamená, že při přetěžování operátoru == musí být naimplementován i operátor != a naopak. Stejné pravidlo platí i pro přetěžované operátory < , > a pro <=,=>.

V příštím díle na nás čekají cykly.

Témata článku: Software, Microsoft, Programování, Case, Díl, Break, Public, Switch, Elsa

Určitě si přečtěte


Aktuální číslo časopisu Computer

26 procesorů v důkladném testu

Zhodnotili jsme 18 bezdrátových reproduktorů

Jak fungují cash back služby?

Pohlídejte své děti na internetu