C++ programozás 2. – Alapok

Első programunk, avagy minden kezdet nehéz?

Ahhoz, hogy az első C++ programunkat megírhassuk, egy IDE, vagyis Integrated Development Environment (Integrált Fejlesztői Környezet) megléte szükséges, lehetőleg olyan, amelyet az emelt érettségin választani lehet. Itt a Code::Block IDE az engedélyezett. Mivel egy egyszerű szövegszerkesztővel is lehet programokat írni, akár úgy is nekikezdhetnénk a munkának, de én javasolnám, hogy valamilyen fejlettebb szövegszerkesztőt használjunk, ami kódszínezéssel és egyéb szolgáltatásokkal segíti munkánkat.

Első C++ programunk legyen mondjuk ez:

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello vilag!" << endl;
    return 0;
}

Az első és nagyon fontos dolog, hogy a c++ programozási nyelv különbséget tesz kis- és nagybetűk között. A “valami” és “Valami” szavak különbözőnek számítanak! Ez a későbbiekben számos hiba forrása lehet és lesz is! Nézzük meg, milyen részekből áll ez a program, amit egyfajta alapnak is tekinthetünk!

Rögtön az első sor magyarázatra szorul:

#include <iostream>

A c++ a be és kimeneteket alapértelmezetten adatfolyamokkal valósítja meg. Ennek az okait és mélységeit nem kell most megérteni, egyelőre fogadjuk el, mint tényt. Ahhoz, hogy az alapértelmezett ki és bemeneti csatornákat használhassuk, két dolgot kell majd használnunk:

  • cout – Alapértelmezett kimeneti csatorna.
  • cin – Alapértelmezett bemeneti csatorna.

Ezek a ki és bemeneteket kezelő utasítások egy iostream nevű előre megírt függvénykönyvtárban találhatók. Ezeket a programjaink nem ismerik alapértelmezetten. Ahhoz, hogy ezeket használhassuk, be kell illeszteni valahogy a programunkba. Természetesen nem arról van szó, hogy megkeressük a telepített keretrendszerrel együtt telepített c++ kódok között, hanem megmondjuk a forráskódunknak, hogy ezeket a függvénykönyvtárakat tartalmaznia kell, mert használni szeretnénk. Ezt nevezzük include-nak. Ezzel ezek az előre megírt kódrészek a programunk részévé válnak, ezáltal szabadon használhatjuk őket.

Nézzük a következő részt:

using namespace std;

A c++ nyelvben rengeteg előre megírt funkció létezik. Ezeknek egyedi nevekkel kell rendelkeznie. Ahhoz, hogy ez a sok név kezelhető legyen, egymástól logikailag elválasztható legyen, úgynevezett névterekbe rendezték őket. Nekünk például az adatok kiírásához, beolvasásához szükség van a cout és cin utasításokra, melyek az std (standard) névtérben találhatóak. Ahhoz, hogy az utasításoknál ne kelljen minden esetben megadni, hogy pontosan hol találhatóak, globálisan, az egész programunkra nézve megadhatjuk az std névtér használatát a using kulcsszóval.

A using-ot azért óvatosan kell használni, főleg különböző névterek használata esetén, mert ha több névtér ugyanolyan nevű dolgokat tartalmaz, akkor ütközés lép fel. Ez elkerülhető azzal, hogy a using használata helyett közvetlenül megadjuk a használni kívánt dolog névterének nevét:

#include <iostream>

int main()
{
    std::cout << "Hello vilag!" << std::endl;
    return 0;
}

Ez viszont, ha sokszor használjuk, és más névtérre nincs szükségünk, ami ütközést okozna, sok felesleges gépelést rak a nyakunkba, ezért kényelmi okokból maradhatunk a globális std használatánál.

Lássuk akkor a következő részt:

int main()
{
    cout << "Hello vilag!" << endl; 
    return 0;
}

Ez egy metódus. A main metódus a program úgynevezett belépési pontja. Ez azt jelenti, hogy amikor a programunkat elindítjuk – amely program akár több, különálló fájlból is állhat – ennél a pontnál kezdi meg a működését, és halad sorban az utasítások között. A metódus előtt a metódus visszatérési értékének típusa szerepel. Egyelőre jegyezzünk meg annyit, hogy a main metódus egy egész számot (int) vár eredményként, melyet a metódus végén meg is kap:

    return 0;

Zárójelben jegyzem meg, hogy míg a metódusok esetén kötelező a megadott metódus típusának megfelelő visszatérési értéket visszaadni, ez a main metódus esetén elhagyható. Mivel azonban egy új project létrehozásakor a fejlesztői környezet automatikusan beilleszti a main végére, semmi gond nincs belőle, ha ottmarad.

Nézzük a következő sort, ami jelen esetben csak egy { jel. Ez egy blokk nyitását jelenti, egyfajta zárójelezés. A c++ nyelvben a blokkokat (utasítások sorozatát) { } jelek közé tesszük. Mint a matematikában, úgy a programozásban is nagyon fontos, hogy a jelekhez, legyen az { [ vagy ( jel, mindig tartozzon nyitó és záró pár is. Ha ezek közül akár csak egy is hiányzik, akkor a programunk nem fordítható le, fordítási hibát eredményez.

A fordítási hiba egy programkód esetén azt jelenti, hogy nem felel meg az adott programnyelv “nyelvtani” szabályainak. Ezek jellemzően zárójel hibákat, pontosvessző hibákat jelentenek, melyeknek mindnek a helyén kell lennie, hogy nyelvtani szempontból hibátlan kódot kapjunk. Ez persze nem azt jelenti, hogy a programunk tökéletes, csak a fordító fogadja el. Az már csak megszokás kérdése, hogy ezeket a blokk jeleket ki hogyan használja. Majd erre nézünk később pár példát.

Nem szabad viszont elsiklani egy nagyon fontos dolog felett ebben a sorban, amit nagyon komolyan kell vennie annak, aki programozni akar. Ezzel a fontos dologgal kezdődik az egész sor. A behúzásról van szó. A blokkjelek közötti sor beljebb kezdődik, mint az előző. Miért? Mert ez a sor egy blokkon belül található. Az előző sorban ugye nyitottunk egy blokkot, mert az osztály esetén kötelező blokkot használni. Az osztályban változókat és metódusokat (ami utasítások sorozata) fogunk használni. Egy blokkon a sorokat ajánlott beljebb kezdeni, hogy lássuk, ezek a sorok az adott blokkhoz tartoznak. Ennek nagyon fontos szerepe lesz a kód olvashatóságának szempontjából.

Nagyon fontos ezt már az elején megszokni, ha blokkot nyitunk, akkor a blokk sorait beljebb kell kezdeni. A blokk behúzását többféle módszerrel oldják meg. Van aki tabulátorral, van aki szóközökkel, van aki 2 szóközzel, van aki 4-gyel, 8-cal, stb. A lényeg a következetesség. Az első blokk egy szinttel kezdődjön beljebb, a következő, ami ezen a blokkon belül van egy újabb szinttel, stb. Erre a példakódban is látunk egy mintát, a kiíratást végző sor már a main() metódus blokkjában van, ezért az 4 szóközzel kezdődik beljebb.

A következő sor már egy tényleges program utasítás.

    cout << "Hello vilag!" << endl; 

A cout egy alap kimenetet kezelő utasítás, mely szöveges kimenet esetén az úgynevezett konzolba (parancssori ablak) írja ki a kimenetet. Emlékszel, ezért volt szükség az iostream include-olására. A kiíratás során megadjuk először, hogy kimeneti vagy bemeneti adatfolyamot szeretnénk használni, jelen esetben kimenetit. Utána átirányítjuk azokat a dolgokat, melyeket a kimenetben szeretnénk megjeleníteni. Az átirányítás jele a << vagy >> mellyel az irányát is megadjuk. Kimenet esetén a kimenet (konzol) irányába << mutat a jel. Ezzel a jellel gyakorlatilag össze is lehet fűzni a különféle típusú kiíratni kívánt dolgokat, legyen az szöveg, szám, változó tartalma, függvény eredménye. Ezeket természetesen olyan sorrendben kell a kimenet irányába terelni, amilyen sorrendben össze szeretnénk fűzni őket.

A Hello vilag! rész természetesen egy szöveg. A szöveges adatokat minden esetben idezőjelek “” közé tesszük. Ezeknek a zárójelekhez hasonlóan természetesen párban kell állniuk. Ehhez hozzáfűzünk egy endl jelent, ami egy úgynevezett új sor karakter. Ennél a pontnál a kimeneten új sor kezdődik, vagyis az esetleges további kiíratások nem folynak össze az előzővel.

Nagyon fontos dolog, a kiíratást végző utasítás végén lévő pontosvessző! A c++ nyelvben minden egyes utasítást pontosvesszővel zárunk le. Egy utasítás, egy pontosvessző. Ha egymás után utasítások sorozatát írjuk (például egy blokkban), akkor az egyes utasításokat pontosvesszőkkel választjuk el egymástól. Ezeket az elválasztott utasításokat írhatnánk akár egy sorba is, de az olvashatóság azt kívánja, hogy egy utasítás egy sor. Így olvashatóbb és tagoltabb a kód. Nem a fordítónak szükséges ez, hanem az embernek, aki a kódot nézi. A pontosvessző viszont igencsak megkeserítheti az életünket, ha nem jó helyen használjuk. Ha olyan helyre rakjuk, ahol semmi keresnivalója, akkor a fordító jelezni fogja, hogy gond van. Persze akkor sem azt mondja, hogy rossz helyen van a pontosvessző, hanem maga a rossz helyen lévő pontosvessző okoz máshol gondot, de ha párszor belefutunk ebbe a hibába, utána rendszerint már hamar megtaláljuk. A gond az, hogy olyan helyre is tehetjük, amiért még a fordító se szól, hogy a kódunk nyelvtanilag helytelen, viszont a program nem egészen azt csinálja, amit meg elvárnánk tőle. Ez egy újfajta probléma. A már emlegetett nyelvtani hibát szintaktikai hibának hívjuk, ez az utóbb említett, amikor a programunk lefordul, de nem az elvárásnak megfelelően működik, szemantikai hibáról beszélünk. Annyit jegyezzünk meg most, hogy a pontosvesszőre nagyon ügyeljünk és csak utasítások végére tegyük ki, mert ott a helyük.

A return 0; sorról feljebb már ejtettem szót, ez a main metódusunk eredménye. Ezzel majdnem vége is van a programunknak. Illetve mégsem. Mi maradt ki? A blokkot lezáró } jel. Ha megnézzük a blokkokat nyitó és záró jelek függőlegesen egy oszlopban vannak, így könnyebb a párjukat megtalálni, az azon belül lévő részek pedig minden új megnyitott blokkban például 4 szóközzel beljebb kerültek. Erről később majd még biztosan lesz szó.

Következő lecke: Változók

3 Replies to “C++ programozás 2. – Alapok”

  1. Pingback: C++ programozás 10. – Függvények

Vélemény, hozzászólás?

Az email címet nem tesszük közzé. A kötelező mezőket * karakterrel jelöltük

*

Ez a weboldal az Akismet szolgáltatását használja a spam kiszűrésére. Tudjunk meg többet arról, hogyan dolgozzák fel a hozzászólásunk adatait..