Egyszerűbb feladatok, problémák megoldása.

Utasítások

Egyszerű elágazásban egy utasítás

Az elágazás egy olyan programvezérlési szerkezet, melynek segítségével valamely utasítás, vagy utasításcsoport végrehajtását bizonyos eset bekövetkeztéhez köthetjük.
Az egyszerű elágazás esetén, amennyiben a logikai feltétel kiértékelése IGAZ értékű, úgy a megadott utasításokat végre kell hajtani. Amennyiben HAMIS, úgy az utasításokat nem kell végrehajtani, de folytatódik a program futása az elágazást követő utasítással.
Az egyszerű elágazás általános alakja:
if (<feltétel>) <utasítás>;
A feltétel, jelen esetben logikai típusú feltétel kell legyen. Amennyiben a feltétel IGAZ értékű, úgy az utasítást végre lehet hajtani. Hívhatjuk ezt a feltételt őrfeltételnek is.
Pl.:
int X;
scanf(”%d”,&X);
if (X%2==0) printf(”Az X változóba beírt érték páros szám!”);
if (10<X && X<20) printf(”\n10 és 20 közötti számot adtál me!”);

Egyszerű elágazás

Az elágazás egy olyan programvezérlési szerkezet, melynek segítségével valamely utasítást, vagy utasításcsoportot végrehajtását bizonyos eset bekövetkeztéhez köthetjük.

Két eset lehetséges: vagy végre kell hajtani, vagy nem. Ennek megfelelően az esetet általában valamilyen logikai feltétellel fogalmazzuk meg. Ezen logikai feltételben jellemzően a változóink értékét vizsgáljuk meg, összehasonlító operátorokkal.

Az egyszerű elágazás esetén, amennyiben a logikai feltétel kiértékelése IGAZ értékű, úgy a megadott utasításokat végre kell hajtani. Amennyiben HAMIS, úgy az utasításokat nem kell végrehajtani, de folytatódik a program futása az elágazást követő utasítással.

Az egyszerű elágazás általános alakja:

if (<feltétel>) <utasítás>;

Az ’if’ angol szócska magyarul azt jelenti: ’ha’.

Egyszerű elágazásban több utasítás

Az elágazás egy olyan programvezérlési szerkezet, melynek segítségével valamely utasításcsoportot végrehajtását bizonyos eset bekövetkeztéhez köthetjük.

Amennyiben nem egy, hanem több utasítást (utasításcsoport) szeretnénk ezen feltételhez kötni, úgy az utasításcsoport elejét és végét jelölni kell. Ez gyakorlatilag azt jelenti, hogy blokkjelek közé kell zárni őket („{ … }”):
if (X<10){
printf(”Az X értéke kisebb mint 10”´);
Y = X;
X = X +1;}
A blokkjelek közötti utasítások a szekvencia szabály miatt sorrendben hajtódnak végre.
Jellemző, hogy a blokkjelek közötti utasításokat beljebb kezdjük a program szövegében.

Kétirányú elágazás, egy-egy utasítással

Pl.:
if (X<10) printf(”X kisebb mint 10”);
else printf(”X nem kisebb mint 10");

A fenti kód értelme: amennyiben a logikai feltétel igaz (vagyis az X értéke kisebb, mint 10), úgy hajtsuk végre az utasítás1-t (kiírás a képernyőre), ellenkező esetben (ha hamis) pedig az utasítás2-t (második kiírás a képernyőre).

Kétirányú elágazás

Az elágazás egy olyan programvezérlési szerkezet, melynek segítségével valamely utasítást, vagy utasításcsoportot végrehajtását bizonyos eset bekövetkeztéhez köthetjük. Az esetet logikai feltétellel szoktuk leírni.
A kétirányú elágazás esetén nem csak arra az esetre adunk meg utasításokat, amikor a logikai feltétel IGAZ értékű, hanem HAMIS érték esetére is.
A kétirányú elágazás általános alakja:
if (<feltétel>) <utasítás1>;
else <utasítás2>;
Az ’if’ angol szócska magyarul azt jelenti: ’ha’. Az ’else’ azt jelenti ’különben’.
A fenti kód értelme:
amennyiben a logikai feltétel igaz, úgy hajtsuk végre az utasítás1-t, ellenkező esetben (ha hamis) pedig az utasítás2-t.

Kétirányú elágazás, egy-sok utasítással

Amennyiben az utasítás2 helyére nem egy, hanem több utasítást szeretnénk írni, úgy utasításblokkot kell képezni a kapcsos zárójelek segítségével:
Pl.:
if (X<10) printf(”X kisebb mint 10”);
else
{
printf(”X nem kisebb mint 10”);
X = X*2;
}

Kétirányú elágazás, sok-egy utasítással

Amennyiben az utasítás1 helyére nem egy, hanem több utasítást szeretnénk írni, úgy utasításblokkot kell képezni a kapcsos zárójelek segítségével:
Pl.:
int x;
scanf(„%d”, &X);
if (X<10){
printf(”X kisebb mint 10”);
X = X*2;}else {
printf (”X nem kisebb mint 10”);
X = X / 2;
}
printf(„\nAz új érték:%d”, X);

Kétirányú elágazás, sok-sok utasítással

Amennyiben az utasítás1 és utasítás2 helyére is nem egy, hanem több utasítást szeretnénk írni, úgy utasításblokkokat kell képezni a kapcsos zárójelek segítségével:
Pl.:
if (X<10){
printf(”X kisebb mint 10”); X = X+40;
}else
{ printf (”X nem kisebb mint 10”);
X = X*2;
}

Csellengő ELSE problémája

A kétirányú elágazások estén az IGAZ vagy a HAMIS ág akár további elágazásokat is tartalmazhatnak.
Az alábbi esetet:
if (feltétel1) if (feltétel1) utasítás1;
else utasítás2;
hívjuk csellengő else problémának. Ugyanis kérdéses, hogy az else melyik if-hez tartozik, az elsőhöz, vagy a másodikhoz. Ennek eldöntésében a sorok tördelése nem, de a szabályok ismerete annál inkább segít!
A szabály szerint az ’else’ mindig a hozzá közelebb eső ’if’-hez tartozik, így a fenti problémás esetben a második if-hez. Helyesen tördelve:
if (feltétel1){
if (feltétel2){ utasítás1; }else{ utasítás2 }
};
Ha azt szeretnénk, hogy az ’else’ az első ’if’-hez tartozzon, akkor a második ’if’-et blokkjelek közé kell zárni:
if (feltétel1){
if (feltétel2){ utasítás1;}
}else{ tasítás2; }

Többirányú elágazások, SWITCH

A többirányú elágazás egy olyan programvezérlési szerkezet, melynek segítségével több különböző esethez különböző utasításcsoportot rendelünk.
A ’C’-ben ezt szokásosan a ’switch’ kulcsszó segítségével valósítjuk meg. Általános alakja:

switch( kifejezés )
{
case eset1: utasításblokk1;break;
case eset2: utasításblokk2;break;
case eset3: utasításblokk3;break;
case eset4: utasításblokk4;break;
...
}

A kifejezés, valamely egész szám típusú kell legyen. Az esetekben a kifejezés lehetséges értékei vannak megadva. Tilos két egyforma esetet megadni, de nem kötelező minden lehetséges esetet felsorolni.
Az utasításblokkok végére ’break’ utasítást kell elvileg elhelyezni, ennek hiányában a vezérlés „rácsorog” a következő utasításblokkra is.
Példa:
int jegy;
printf(”Irj be egy erdemjegyet:”);
scanf(”%d”,&jegy);
switch (jegy)
{
case 1:
printf(”elégtelen”);
break;
case 2:
printf(”elégséges”);
break;
case 3:
printf(”közepes”);
break;
case 4:
printf(”jó”);
break;
case 5:
printf(”jeles”);
break;
}

Többirányú elágazások
Az elágazás egy olyan programvezérlési szerkezet, melynek segítségével valamely utasítás vagy utasításcsoport végrehajtását bizonyos eset bekövetkeztéhez köthetjük.

Amennyiben több mint két ilyen utasításcsoportunk, több mint két ilyen esetünk van – a logikai feltétel nem elégséges. Logikai feltétel esetén (mivel az csak két különböző értékű lehet) csak két elágazási irány írható le.

Elvileg a többirányú elágazás leírható sok kétirányú elágazással. Ugyanakkor az ilyen többszörösen egymásba ágyazott kétirányú elágazások áttekinthetetlen és nehezen módosítható kódot eredményeznek.

Többirányú elágazás folyamata
Többirányú elágazás folyamata
BREAK használata
A break értelme, hogy megszakítja az adott utasításblokk végrehajtását, és ugrik a switch blokkot követő első utasításra.
int jegy;printf(”Irj be egy erdemjegyet:”);
scanf(”%d”,&jegy);
switch (jegy){
case 1:
printf(”elégtelen”);
case 2:
printf(”elégséges”);
case 3:
printf(”közepes”);
case 4:
printf(”jó”);
break;
case 5:
printf(”jeles”);
break;
}
Jelen példa esetében ha a jegy=3-al akkor, kiírja a ”közepes” és „jó” szavakat is a képernyőre!

Ugró utasítás a switch-ben
A break hiányában a végrehajtás „rácsorog” a vezérlés a következő utasításblokkra is. Ezt használjuk ki akkor, ha több esetben is ugyanazt az utasításblokkot szeretnénk végrehajtani:

int jegy;
printf(”Irj be egy erdemjegyet:”);
scanf(”%d”,&jegy);
switch (jegy)
{
case 1:

case 2:

case 3:
printf(”hát, ez elég gyenge”);
break;
case 4:
printf(”megfelelő”);
break;
case 5:
printf(”jeles”);
break;
}

Jelen példa jegy=1, jegy=2, jegy=3 esetben is kiírja a „hát ez elég gyenge” szöveget a képernyőre, mivel bármelyik esetben miután belépünk a megfelelő ágba, utána a break hiányában rácsorgunk a következő utasításblokkra.
Más nyelveken (pl. C#) kötelező használni a break-et. Ott ez a trükk nem működik. Ilyen nyelveken ugró utasításokkal tudunk direktben rácsorogni más ágakra.

Többi esetben' ág
Bevezethető egy ’egyébként’ jellegű ág is, a ’deafult’ kulcsszó segítségével:

switch( jegy )
{
case 1: printf(”elégtelen”);break;
case 2: printf(”elégséges”);break;
case 3: printf(”közepes”); break;
case 4: printf(”jó”); break;
case 5: printf(”jeles”9; break;
default: printf(”?? nincs ilyen jegy ??”);break;
}

A ’default’ ág az ágak listájának végén szokott lenni, és akkor kerül végrehajtásra, ha a kifejezés értéke nem egyezik egyik felsorolt esettel sem.
Ebben az esetben pontosan egy ág mindenképpen végrehajtódik. Ha nincs default ág, akkor csak annyit mondhatunk el: legfeljebb az egyik ág hajtódik végre.