6. fejezet: Elágazások

 

Mint minden tisztességes nyelvben, így a C++-ban is vannak elágazások. Persze némi angol tudással a dolog könnyen fog menni!

Alapvető szerkezet:

                        if (feltétel) igaz-ág; else hamis-ág;

 

Nézzük mindezt egy konkrét programban:

---------------------------------------------

//Elágazás

#include <iostream>

using namespace std;

int main()

{

    int szam;

    cout <<"Ez egy elagazas!\n";

    cout <<"Kerek egy egesz szamot! ";

    cin >>szam;

    if (szam<10) cout <<"10-nel kisebb";

                 else cout <<"10-nel nem kisebb";

}

---------------------------------------------

 

Látható, hogy az if-et egyből követi az igaz-ág, tehát hiányzik a máshol megszokott then, viszont javasolt az else (különben) használta az esetleges félreértések elkerüléséért.

 

Azt hiszem, hogy itt az ideje az összehasonlító műveletek leírásának. Íme:

== // egyenlő

!= // nem egyenlő

<< // kisebb

>> // nagyobb

<= // kisebb vagy egyenlő

>= // nagyobb vagy egyenlő

 

Fontos kiegészítés: egyes nyelvi verzióknál ez változhat!!!

Kicsit bonyolítsuk meg a programot. Hamár az előbb volt egy függvény, akkor most is legyen, de ezúttal olyan, ami kizárólag igaz/hamis eredményt adhat vissza.

Szeretném ismételten megjegyezni, hogy (ilyen egyszerű programnál egyenlőre) nem kell még a függvényt használnunk, de később igen komoly haszna lesz, ha pl. ugyanazon programsorokat több tucatszor is meg kell ismételnünk!

A függvény meghívása itt is a nevével történhet, de arra érdemes vigyázni, hogy a feltétel kerüljön zárójelbe!

---------------------------------------------

//Elágazás külső függvénnyel

#include <iostream>

using namespace std;

 

bool igennem()

{

cout << "E'rtheto: volt? (i/n)?\n"; // kérdés kiírása

char valasz = 0;

cin >> valasz; // válasz beolvasása

if (valasz == 'i') return true;

              else return false;

}

 

int main()

{

    int szam;

    cout <<"Ez egy elagazas!\n ";

    cout <<"Kerek egy egesz szamot! ";

    cin >>szam;

    if (szam<10) cout <<"10-nel kisebb\n";

                 else cout <<"10-nel nagyobb\n";

    if (igennem()) cout <<"Rendben\n";

                else cout <<"Javaslom, hogy olvassa ujra!\n";

}

---------------------------------------------

 

Az else ág maga elhagyható!

Az else ágat is lehet még külön bonyolítani (a legtöbb nyelvjárásban) elseif, illetve else if lehetőségekkel, de ezt egyenlőre ne részletezzük!

Fontosabb a többszörös elágazás! Az alapvető szerkezeti szavak erre a következők: switch, illetve case.

Lássuk a következő forrásfájlt mintaként:

---------------------------------------------

//Többszörös elágazás

#include <iostream>

using namespace std;

 

int main()

{

    int szam;

    cout <<"To:bbszo:ro:s elagazas szemleltetese:\n";

    cout <<"Kerek egy szamot a ko:vetkezo:kbo:l: 1,2,3,4,5\n";

    cin >>szam;

    switch (szam)

    {

    case 1: cout<<"elegtelen";break;

    case 2: cout<<"elegseges";break;

    case 3: cout<<"ko:zepes";break;

    case 4: cout<<"jo";break;

    case 5: cout<<"jeles";break;

    default: cout<<"Rossz erteket adott meg!";

    }

    cout <<"\n";

}

---------------------------------------------

Jól látható, hogy itt a hagyományos iskolai osztályzatoknak megfelelő szöveget írja ki a program. Minden egyes elágazásnál (case) ott van a feltétel.

Minden egyes elágazás végrehajtása végén ott van a break, mivel ezzel ugrik ki az elágazásból. Érdemes kipróbálni úgy is, hogy nincs ott egyik break sem!

 

Fontos továbbá, hogyha a vezérlő nem talál olyan feltételt, ami a megadottnak megfelel, akkor elmegy a default részig (kb. alapeset) és végrehajtja azt. De ez a default alapesetben elhagyható!

 

Alternatív megoldás a feltételes elágazásra:

feltétel ? igaz-ág: hamis-ág

Például: 5>3 ? a : b;

Magyarázat: ha 5>3, akkor "a" különben "b" - itt és most ez, ugye, igaz lesz.

 

7. fejezet: Alapvető logikai operátorok

Sokszor szembesültünk azzal, hogy egy feltétel nem elég. Több feltételt is össze kell fűzni. Ilyenkor jöhetnek a jól megszokott logikai operátorok (nem, és, vagy, kizáró vagy, …)

Alapvető logikai operátorok:

! = NOT = nem

&& = AND = és

|| = OR = vagy

 

Íme a megszokott logikai értéktáblázat:

A

B

!A

!B

A && B

A || B

igaz

igaz

hamis

hamis

igaz

igaz

igaz

hamis

hamis

igaz

hamis

igaz

hamis

igaz

igaz

hamis

hamis

igaz

hamis

hamis

igaz

igaz

hamis

hamis

 

---------------------------------------------

//Logikai operátorok

#include <iostream>

using namespace std;

 

int main()

{

    int a,b,c;

    cout <<"Kerem az A erteket (egesz szam): ";

    cin >>a;

    cout <<"Kerem a B erteket (egesz szam): ";

    cin >>b;

    cout <<"Kerem a C erteket (egesz szam): ";

    cin >>c;

    char eredmeny;

    if ((a>b) && (a>c)) eredmeny = 'A';

    if ((b>a) && (b>c)) eredmeny = 'B';

    if ((c>a) && (c>b)) eredmeny = 'C';

    cout <<"\n\nErtekeles: \n";       //Ezt két üres sorral választottam el a bekéréstől

    cout <<"A legnagyobb ertek: " <<eredmeny;

}

---------------------------------------------

A fenti példából is látható, hogy a logikai feltételeket nem simán össze kell fűzni, hanem célszerű zárójelbe is tenni, mivel ilyen esetben a fordító simán megbirkózik az általunk kívánt logikai összefüggésekkel.

 

Gyakorlati példának vegyünk a billentyűzetről két számot és írassuk ki őket csökkenő sorrendben!

---------------------------------------------

//Logikai operátorok

#include <iostream>

using namespace std;

 

void csere(int &x, int &y)

{

    int valtozo;

    valtozo= x;

    x = y;

    y = valtozo;

}

 

int main()

{

    int a,b;

    cout <<"Kerem az A erteket (egesz szam): ";

    cin >>a;

    cout <<"Kerem a B erteket (egesz szam): ";

    cin >>b;

    if (b>a) csere(a,b);              // A cserét külső függvényben oldom meg!

    cout <<"\n\nSorrendben: \n";

    cout <<"a=" <<a <<" > b= " <<b;

}

---------------------------------------------

 

Vannak bitenkénti operátorok is, amik a más programozási nyelveken megszokottak:

&         AND   (Bitwise AND) bitenkénti ÉS

|           OR      (Bitwise Inclusive OR) bitenkénti megengedő vagy

^          XOR   (Bitwise Exclusive OR) bitenkénti kizáró vagy

~          NOT   (Unary complement - bit inversion) teljes ellentét bitenként

<<       SHL    (Shift Left) eltolás balra

>>       SHR    (Shift Right) eltolás jobbra

 

További információkért érdemes elolvasni: http://cplusplus.com/doc/tutorial/operators/