Hmmm, hogy is szoktam elkezdeni a cikkeimet ? Semmi nem jut eszembe, ma úgy látszik rossz formában vagyok, az első sor megszülése is 5 percig tartott. 

Na nem baj, hol van az megírva, hogy egy irománynak kell hogy legyen eleje ?

Szóval ELSE

Eddig az if utasítást így ismertük(else nélkül): ha a feltétel igaz, hajts végre egy utasítás(blokk)(o)t, ha meg nem, akkor ne strapáld magad. Azonban most ez else-vel: ha a feltétel igaz, hajtsd végre csak az első utasítás(blokk)(o)t, ha hamis, akkor meg csak a másodikat. 

Ez C-ül: if(feltétel)

utasítás1(blokk);

else

utasítás2(blokk);

Igaz ugyan, hogy a blokk-ot mindenhol zárójelbe tettem, mert a fordító egy utasításnál nem teszi kötelezővé a kapcsok használatát, azonban ilyenkor is érdemes őket használni, ha el akarjuk kerülni az alábbi hibát, mely az if-ek egymásba-ágyazásánál keletkezhet:

if (feltétel1)
if (feltétel2)
utasítás1;
else
utasítás2;

Számunkra az else nyilvánvalóan az első if-hez tartozik, a fordító számára viszont a másodikhoz. A kapcsok használatával ez elkerülhető.

Ha már a hibáknál tartunk (lehet, hogy találóbb lene a "hogy ne programozzunk C-ben" című):

if (a=0) ptrintf("a változó nulla");

Eme sor hatására nem fog semmi megjelenni a képernyőn, lehet az a akármekkora nulla. Viszont hibaüzenetet sem kapunk. (A kultúráltabb compiler azért elereszt egy Warning-ot). Az a=0 értékadást jelent. Tehát nem elég, hogy nem jó az if-es sorunk, még a változónkat is lenulláztuk. A fordító nullázza a változót, majd, ha ennek értéke nem nulla(nullázás után valószínűtlen), akkor végrehajtja az utasítást, ha nulla (naná hogy nulla lesz), akkor nem.

Tehát, mint már említettem, a két egyenlőségjel jelent összehasonlítást.

Nézzük, hogy lehet a feltételeket kapcsolni:

logikai operátorokkal:

&& és

|| vagy

! nem

pl.: if (c<=‘9'&& c>=‘0') printf("ez egy szam"); vagy

if (!(c<=‘9'&& c>=‘0')) printf("ez nem egy szam"); vagy

if (err1 || err2) printf("bibi");

Az utolsó példa úgy vélem némi magyarázatra szorul. Az err1 illetve err2 dolgok változók, azonban a C feltételként is tudja kezelni őket. Ha értékük 0, akkor a feltétel hamis, ha !0 (haha) akkor igaz. Így lehet a kezdő programozók számara érthetetlenné tenni a forráskódot: 

if !(a) valami; 

Akkor teljesül, ha a nulla.(sokkal elegánsabb, mint az ( a= =0) nem?)

Feltételes Kifejezések

Eddigi ismereteink már képessé tesznek minket arra (remélhetőleg), hogy két szám közül kiválasszuk a kisebbet. Nosza!

if(a<b) 
x=a;
else 
x=b;

Bizony! Ez sikerült! Viszont ha az ember C-ben csinál ilyet, akkor körberöhögik. Ugyanis vannak feltételes kifejezések. Íme a bonyolult feladat.

x=a<b ? a:b;

Ez az egy sor ugyanazt csinálja, mint az a másik négy. Akkor talán próbáljuk megérteni! Így nézünk ki:

feltétel ? kifejezés1:kifejezés2

Ha a feltétel igaz, akkor az egésznek a kifejezés1 lesz az értéke, ha hamis, akkor a kifejezés2.

Nézzük, mi van, ha ki is akarjuk írni:

printf("%d",a<b?a:b);

Innen látszik a legfőbb előnye az if else szerkezettel szemben. Ez az előny pedig az, hogy kifejezés, így lehet paraméter is, nem kell egy külön változó, amibe letesszük az értéket.

Switch-case

A switch() a többtagú tesztelést teszi lehetővé, egész kifejezéseknél.

Ja, hogy mi az a többtagú tesztelés? Nézzünk egy példát:

c=getchar();

if (c==‘A') printf("Akkor se írok ki semmit!"); else

if (c==‘B') printf("Béna vagy!"); else

if (c==‘C') printf("Ceretnéd mi?"); else printf(" Akkor is kiírok valamit!");

Tehát van egy változónk, amiről azt szeretnénk tudni, hogy egyenlő-e bizonyos konstansokkal. Ha túl sok hasonlításunk van, elég bénán fog kinézni a forráskódban (2 oldal if). Ezért van a switch.

switch(c)
{
case ‘A' : printf("Akkor se írok ki semmit!");
break; 
case ‘B' : printf("Béna vagy!");
break; 
case ‘C' : printf("Ceretnéd mi?");
break; 
default : printf(" Akkor is kiírok valamit!");
}

A switch-nek csak egész paramétert adhatunk meg.(egyik hátránya az if-es játékkal szemben) A program sorban összehasonlítja ezt a kifejezést a case-ek mögött lévő egész konstansokkal. Ha egyenlő, a program átadja a vezérlést a case mögött lévő utasításblokknak. Ha egyikkel sem egyenlő, akkor a default: mögötti utasításblokk hajtódik végre. A default ág opcionális (nem kötelező, ki lehet hagyni). Ez oké, de mi az a rengeteg break? A világ mindig egy fokkal bonyolultabb, mint ahogy azt legrémesebb álmainkban gondolnánk. Ez az egész dolog nem olyan sorrendben fordítódik le, mint ahogy mi leírtuk. Az összes blokkunk szépen egymás után van a gépi kódban, és a switch a kifejezés értékének megfelelően ugrasztja a procit az adott blokkra. Miután a blokk végrehajtódik, break nélkül nem ugrik vissza a swtitch-re, hanem rácsorog a többi blokkra is. A break mondja meg, hogy öreg ez itt a vége, tűnj vissza. (azaz előre a switch-et záró kapocsra). Egyedül a default-os ágba nem kell break, hiszen itt rögtön ott van a zárókapocs. A break egyébként normális esetben a ciklusból való azonnali kilépést jelenti.(majd részletesebben is vesszük). Ebből aztán következik a swich másik hibája, mégpedig úgy, hogy a switch-ből nem tudjuk megszakítani a ciklust, mert a break csak a switch-et rendezi el. De, hogy ne csak a hátrányairól szóljak, a switch() gyorsabb, és átláthatóbb és elegánsabb. (Az elegánsabbat csak azért írtam, hogy több előny legyen, mint hátrány).

Ha már annyit feszegettem azt a break-et, hát nézzük:

BREAK-CONTINUE

No, mint említettem, a break nem egyetlen, (nem igazi) feladata a switch(). A ciklusból való azonnali kilépést lehet vele elérni:

while(...)
{
if (err)
{
...;
break;
}
...
}

Amint látszik leggyakrabban valamilyen hiba lekezelésénél szokjuk(magyartalan, de direct vót) használni, hogy ki tudjunk lépni a ciklusból. Ha több ciklus van egybeágyazva, a break mindig csak a saját ciklusát szakítja meg.

A CONTINUE a break tesója. Hatására a ciklus továbblép, folytatódik. Úgy is elképzelhetjük, hogy visszaugrik a ciklust nyitó kapocsra. őt akkor szoktuk használni, ha valamilyen eseményt, nem kívánunk kezelni, továbblépjük, várunk egy másikat. Pl. ha el akarjuk hitetni a felhasználóval, hogy az a hosszú fehér alul (szpész) nem gomb:

while((c=getchar())!=EOF)
{
if c==‘ ' continue ;
printf("%c",c);
if (c==27) break;
}

A példa kissé erőltetett, de remélem érthető. Mint látható elég kényelmesen ugrálhatunk ki, léptethetjük tovább a ciklust. DE. Most jön a fekete leves: Az okosok szerint a break és a continue nem felel meg a strukturált programozás alapelveinek, a programot követhetetlenné, logikátlanná teszi, ezért a continue-t egyáltalán nem, míg a break-et csak a switch()-ben használjuk. Meg kell hogy mondjam, ebben tényleg van valami, úgyhogy kerüljük e két utasítás használatát, kivéve ha nincs jobb megoldás.(ez elég ritkán van) 

Jópofa mi? Fél (vagy ahogy a főszerkesztő tördelését ismerem negyed) oldalon tárgyalok két utasítást, azért, hogy a végén azt mondhassam, kerüljük. 

EZ VAN!