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/