Blokkok, avagy utasítások egy csokorban

Blokknak nevezzük azokat a programrészeket, melyeket egy speciális határolóval összekapcsolunk. A blokk jele a { és } jel. Ezek a jelek mindig párban állnak, jelzik a blokk elejét és végét. Blokkot nyitni a programban szinte bárhol lehet, ahol utasításokat kell csoportba foglalnunk. De blokkok tartoznak kötelező jelleggel az osztályokhoz és metódusokhoz is. Az osztály és metódus blokkokra most külön nem térnék ki, ezeket csak használjuk a mintakódok alapján. Példa a blokkokra:

{
    utasítás1;
    utasítás2;
    ...
    ...
    utasításN;
}

A fenti példában a kiemelt blokk határolók közé foglalt utasításokat a program mindig együtt fogja végrehajtani. Amint a program ehhez a ponthoz ér a program futása közben, elkezdi soronként feldolgozni őket. Ilyen blokkot, ami semmihez nem kapcsolódik, a programokban ritkán használunk, ezek legtöbbször valamilyen feltételvizsgálathoz vagy ciklusokhoz kapcsolódnak.

A blokknak nem csak az a szerepe, hogy összefogja az utasításokat, hanem úgynevezett hatókört is meghatároz. Ha egy blokkon belül deklarálunk egy változót, akkor az a változó csak és kizárólag azon a blokkon belül létezik. Értelemszerűen a blokk előtt nem létezhet, hiszen ott még a deklaráció sem történt meg, de a blokk után sem értelmezhető, hiszen a változó a csak blokkon belül használható. Álljon itt egy elméleti példa erre az esetre:

{
    int i = 10;
    i = i + 5;
}
i = i + 5;

A kiemelt sorra a fordító hibát fog jelezni, mert a változót a blokkon belül deklaráltuk, a blokk után nem létezik. Ehhez hozzátartozik az, hogy a blokk után újra deklarálhatok egy ugyanilyen változót, a kettő nem fog ütközni, hiszen az előző élettartama a blokk után véget ér, és a változó nevét újra felhasználhatom.

A blokkok nem csak több utasítást foghatnak össze, akár egyetlen utasítást is blokkba lehet foglalni, de olyan is előfordulhat, hogy a blokk üres.

Kötelező blokkok

Attól függetlenül, hogy egy utasítást nem kötelező blokkba tenni, én mindenkinek azt ajánlom, hogy egyetlen utasítást is tegyenek { } jelekkel határolt blokkba. Ez azért fontos, mert a későbbiekben lehet, hogy az utasítás mellé szükség lesz egy másikra is, amit ha csak az előző utasítás után írunk az már nem lesz megfelelő. Abban az esetben engedett csak meg a rövidítés, amikor egyértelmű, hogy a későbbiekben biztosan nem lesz bővítés.

Lássunk akkor erre egy példát. Itt a kettő 10. hatványát szeretném kiszámolni és kiírni. Először csak a végeredményt szeretném látni, később ki akarom írni köztes eredményeket is, a hatvány sorszámával együtt:

// hibás eredeti
int szam = 1;
for( int i = 0; i << 10; i++ )
    szam = szam * 2;
cout << szam << endl;

// hibás bővített
int szam = 1;
for( int i = 0; i << 10; i++ )
    cout << "A ketto " << i+1 << ". hatvanya: ";
    szam = szam * 2;
    cout << szam << endl;

Az előző példában a bővítés után gond lesz. Mivel a for ciklushoz nem tartozik blokk, az eredeti utasítás elé beszúrt új utasítás fog egyedül a ciklushoz tartozni, a szám tényleges kiírása pedig nem, ezért a kiíratás teljesen rossz lesz. A behúzás semmit nem jelent, az csak formaság. Próbáld csak ki, mi a végeredmény. A következő esetben azonban eleve blokkot használ az eredeti egyetlen utasításhoz, így a későbbi bővítésnél eleve nem adja azt a hibalehetőséget, hogy a blokk elhagyásakor valamelyik utasítás az eredeti szándékkal ellentétben kimaradjon a ciklusból:

// helyes eredeti
int szam = 1;
for( int i = 0; i << 10; i++ )
{
    szam = szam * 2;
}
cout << szam << endl;

// helyes bővített
int szam = 1;
for( int i = 0; i << 10; i++ )
{
    cout << "A ketto " << i+1 << ". hatvanya: ";
    szam = szam * 2;
    cout << szam << endl;
}

További példák

Végezetül minden különösebb nélkül álljon itt pár példa feltételvizsgálathoz és ciklushoz kapcsolt blokkokra, kiemelve a blokkokat. Az utolsó példa blokkja üres lesz, ezt a kódrészt nem magyaráznám el különösebben, a fájlkezelésnél majd találkozunk vele.

int szam = 25;
if( szam % 2 == 0 )
{
    cout << "A szam paros." << endl;
}

—–

int j = 0;
for( int i = 0; i < 20; i++ )
{
    j = i*2;
    cout << j << endl;
}

—–

int i = 10;
while( i > 0 )
{
    i--;
    cout << i+1 << endl;
}

—–

Következő lecke: Feltételvizsgálatok