Bevezetés a C++ programozásba A program fogalma: A program nem más, mint számítógép által végrehajtható utasítások sorozata. A számítógépes programokat különféle programnyelveken írhatjuk. Ilyen nyelvek a Logo, C, C++, Pascal, Python, Java, PHP, stb. Sajnos a számítógép ezeket a nyelveket alapállapotban nem érti meg, ezért ún. fordítóprogramokra van szükségünk. A fordítóprogram az általunk megírt programot a számítógép saját nyelvére az ún. gépi kódra fordítja. A fordítás történhet a program készítésekor (compiler fordítók) vagy a program futtatásakor (interpreter fordítók). Az előbbire példa a C, C++ és a Pascal, az utóbbira a Logo, Python, JavaScript és a PHP. (A Java mindkét módszert alkalmazza.) A változó fogalma: A számítógépes programok működésük folyamán különféle típusú adatokat tárolnak hosszabb-rövidebb ideig. Az adatok tárolására szolgálnak az ún. változók. A változó nem más, mint egy névvel ellátott rekesz a memóriában. Olyan, mint egy fiók egy sokfiókos szekrényben. Egy változóban egyszerre csak egy adat lehet. Ha újabb adatot teszünk bele, a régi törlődik. A változókat a program elején létre kell hozni (úgymond: deklarálni kell). Deklarálásnál meg kell adni a változó nevét és típusát, azaz, hogy milyen típusú adatot akarunk benne tárolni. A legfontosabb adattípusok a következők: INT FLOAT CHAR STRING egész szám valós szám (törtek és egészek is) egy karakter (betű) szöveg Az első C++ programunk: kiírás, beolvasás, összeadás Az itt következő program bemutatja a C++ programozási nyelv legfontosabb jellegzetességeit. A programsorok végén ún. megjegyzések szerepelnek, amelyben leírtuk a programsor jelentését. (A megjegyzések a // jellel kezdődnek és a programozó eligazodását segítik a programban. A megjegyzéseket a számítógép nem tekinti utasításoknak.) Az alábbi program beolvas két egész számot és kiírja az összegüket: //Ezt a két sort minden program elejére odaírjuk //(Egyelőre elég ennyit tudnunk róluk ) int main() //Itt kezdődik a program fő része int x,y; //Egész típusú változók létrehozása (deklarációja) cout << "Irjon be egy szamot!\n"; //Szöveg kiírása soremeléssel cin >> x; //Adatbeolvasás a billentyűzetről az x változóba cout << "Irjon be meg egy szamot!\n"; cin >> y; cout << "A ket szam osszege: " << x+y << endl; //többszörös kiírás, a végén soremelés return(0); //Itt a program fő részének vége A számítógépes programok tehát a számítógépnek adott utasításokból állnak. A program utasításait felülről lefelé haladva, egymás után hajtja végre a számítógép. Az adatok beolvasására és kiírására szolgálnak a következő utasítások: cout << kiírandó adat Egy szövegnek, számnak, vagy egy változó értékének kiírása a képernyőre. Ha szöveget akarunk kiíratni, akkor azt idézőjelek közé kell tenni. Ha a kiírás után új sort szeretnénk kezdeni, akkor használjuk a \n vagy az endl jelet. cin >> változónév Valamilyen adat beolvasása a billentyűzetről, és tárolása egy változóba. Ennél az utasításnál tehát nem azt kell megadni, hogy mit olvasson be a gép (ezt nem is tudhatja a programozó), hanem, hogy a beolvasott adatot hol raktározza el! Bevezetés a C++ programozásba (1/10. oldal)
Figyelem: A C++ programozási nyelv különbséget tesz a kis- és a nagy betűk között! A legtöbb utasításnak kisbetűsnek kell lennie! A változók neve tartalmazhat nagybetűket is, de a nyelv itt is megkülönbözteti a kis- és nagybetűket. A változók nevének betűvel kell kezdődnie és csak betűket, számjegyeket és aláhúzás karaktert tartalmazhat. A változókban kétféleképpen tárolhatunk adatokat: Egyrészt a már megismert módon a billentyűzetről beolvasva (cin >> változónév), másrészt az ún. értékadó operátor (=) segítségével. Például a következő utasítás az x változóba teszi a 34 számot: x = 34 ; Ha egy változó szöveg típusú, akkor értékét idézőjelek között kell megadnunk, ha pedig karakter típusú, akkor az angol nyelvben használatos aposztrofok közé kell tennünk: szovegvaltozo = "ezt a szöveget akarjuk beletenni ; betuvaltozo = A ; Operátorok A programozásban operátoroknak nevezzük a különféle műveleti jeleket. Az operátorok az adatokon operálnak, azaz különféle műveleteket végeznek az adatokkal. Ezeket az adatokat operandusoknak is nevezzük. Például az 5 + 6 műveletben a + jel az operátor, az 5 és 6 számok az operandusok. A legfontosabb aritmetikai operátorok a négy alapművelet, a szokásos szimbólumokkal. (+ * /) Mind a négy művelet egész és valós típusú operandusok esetén is működik, de az osztás esetében vigyáznunk kell arra, hogy egész típusú operandusok osztásakor egész eredményt fogunk kapni, és az osztási maradék elvész! Tekintsük például a következő programrészletet: int a=12; int b=5; float f; f=a/b; A programrészlet után az f valós típusú változó értéke a 2.0 érték lesz (és nem 2.4)! Amennyiben a hányados törtrészére is szükségünk van, akkor az a és b változókat valós (float) típusúnak kell deklarálni, vagy a művelet során (ideiglenesen) valós típusúvá kell alakítani a következő módon: int a=12; int b=5; float f; f=float (a) / float (b); Szintén fontos a maradékos osztás operátora a % jel. A művelet az osztás maradékát adja vissza, és természetesen csak egész típusú változók használata esetén alkalmazható. Pl: 12 % 5 eredménye 2. (Hiszen a 12-t 5-tel osztva 2 maradékot kapunk.) A programokban gyakran kell összehasonlítani különböző értékeket. Ennek elvégzésére az összehasonlító operátorokat használjuk. Ezek a következők: <, >, <=, >=, = = és!=. Ha ezekkel két változót vagy kifejezést hasonlítunk össze, akkor az eredmény igaz, vagy hamis lehet. Figyeljünk arra, hogy az egyenlőség operátora két egymás után írt egyenlőségjel! (Az egyszeres egyenlőségjel ugyanis az értékadó operátor jele!) A!= operátor jelentése: nem-egyenlő. A logikai kifejezésekben gyakran összetett feltételeket is meg kell fogalmazni, erre szolgálnak a logikai operátorok. Ezek a következők:! a tagadás (NEM), && a logikai ÉS, a logikai VAGY művelete. A léptető operátorok a változó értékének eggyel való növelésére, vagy csökkentésére szolgálnak. A ++ eggyel növeli, a eggyel csökkenti a változó értékét. (A C++ nyelvben nem szokás a más programnyelvekben használatos a=a+1 értékadás, helyette inkább a léptetést használjuk.) Bevezetés a C++ programozásba (2/10. oldal)
Véletlenszámok generálása, elágazás a programban A következő program egy egyszerű szorzótábla gyakorló. A program kisorsol két egész számot 0 és 10 között, kiírja a számokat, megkérdezi a szorzatukat és ellenőrzi az eredményt. #include <cstdlib> #include <ctime> int main() int x,y,tipp; srand(time(0)); x=rand()%11; y=rand()%11; cout<<"irja be a helyes eredmenyt!\n"; cout << x << " X " << y << " = " ; cin >> tipp; if (tipp==x*y) cout << "Helyes!\n"; //ezek a véletlenszám-generátor //működéséhez kellenek //változók létrehozása //a véletlenszámok összekeverése //véletlenszám generálása 0 és10 között //(a % művelet a maradékképzés) //kérdésfeltevés //a válasz beolvasása //ha a tipp helyes, akkor kiírjuk, hogy helyes, else cout<<"hibas! A helyes eredmeny: "<<x*y<<endl ; //különben ezt írjuk ki return(0); A programokban lehetnek olyan utasítások, sőt akár egész programrészek, amelyeket csak bizonyos feltétel teljesülése esetén kell végrehajtania a számítógépnek. Például a fenti programban csak akkor dicsérjük meg a felhasználót, ha helyesen adja meg a szorzás végeredményét, ellenkező esetben a gép írja ki a helyes eredményt. Az ilyen programszerkezetet elágazásnak, vagy feltételes utasításnak nevezik. A feltételes utasításnak két formája van. Az egyszerűbb forma a feltétel teljesülése esetén végrehajtja az utasítást, egyébként nem csinál semmit: if (feltétel) utasítás; Ha például a fenti programban az alábbi utasítássort írtuk volna: if (tipp==x*y) cout << "Helyes valasz, ugyes vagy!\n" ; Akkor helyes válasz esetén a gép megdicsérné a felhasználót, hibás válasz esetén viszont nem történne semmi! Amennyiben a feltétel után több utasítást szeretnénk megadni, akkor ún. utasítás-blokkot kell alkalmaznunk: if (feltétel) utasítás1 ; utasítás2 ; A feltételes utasítás másik formája lehetőséget ad arra is, hogy a feltétel nem-teljesülése esetén is történjen valami. Ha a feltétel igaz, akkor az utasítás1-et hajtja végre a gép, különben az utasítás2-t. if (feltétel) utasítás1; else utasítás2; Összetett feltételek az elágazásokban Feltételvizsgálatoknál gyakran szükségünk van a logikai operátorok használatára. Az alábbi példaprogrammal a testtömeg-indexünket vizsgálhatjuk meg: int main() Bevezetés a C++ programozásba (3/10. oldal)
float magassag, tomeg, tti; cout<<"irja be a testmagassagat meterben!\n"; cin>>magassag; cout<<"irja be a testtomeget kilogrammban!\n"; cin>>tomeg; tti=tomeg/(magassag * magassag); if (tti<18) cout<<"on nagyon sovany!\n"; if (18<=tti&&tti<25) cout<<"on normalis testalkatu.\n"; if (25<=tti&&tti<30) cout<<"on tulsulyos!\n"; if (30<=tti) cout<<"on veszelyesen elhizott!!!\n"; return(0); //ha a tti 18 ÉS 25 között van Ciklusok, avagy ismétlés a programban Ez a program a korábbi szorzótábla-gyakorló program továbbfejlesztett, többmenetes változata. #include <cstdlib> #include <ctime> int main() srand(time(0)); int x,y,tipp; int jo=0,rossz=0; char v; do x=rand()%10+1; y=rand()%10+1; cout<<"irja be a helyes eredmenyt!\n"; cout<<x<<" X "<<y<<" = "; cin>>tipp; if (tipp==x*y) cout<<"helyes!\n"; jo++; else //a véletlenszámok összekeverése //változódeklaráció //változódeklaráció kezdőérték-adással //karakter típusú változó deklarációja //ciklus indul //véletlenszám generálása 1 és10 között //(a % művelet a maradékképzés) //ha a tipp helyes //változó növelése 1-gyel //különben-ág cout<<"hibas! A helyes eredmeny: "<<x*y<<endl; rossz++; cout<<"eddig "<<jo<<" helyes, valamint "<<rossz<<" hibas valasza volt.\n"; cout<<"szeretne meg gyakorolni? (i/n)"; cin>>v; while (v=='i'); //ciklus vége. Ide a ciklus folytatásának feltétele kell! return(0); A programozásban gyakran van szükség arra, hogy a program egy részét megismételjük, azaz újra végrehajtassuk a számítógéppel. Az ilyen programszerkezetet ciklusnak nevezik. Az előző programban például addig ismételtük a szorzótábla gyakorlását, amíg azt a felhasználó óhajtotta. A C++ nyelvben ezt az ismétlést a következőképpen írhatjuk le: do utasítás-blokk while (feltétel) ; Bevezetés a C++ programozásba (4/10. oldal)
A ciklusban szereplő utasítás-blokkot ciklusmagnak nevezzük. A számítógép mindaddig ismétli a ciklusmag utasításainak végrehajtását, amíg a feltétel igaz marad. (A ciklusmag utasításai egyszer mindenképpen végrehajtódnak, mivel a feltételt csak a ciklusmag végrehajtása után vizsgálja meg a gép.) Óvatlan programozók időnként ún. végtelen ciklust készítenek, amelynek feltétele mindig igaz marad (soha nem válik hamissá) és így a program soha nem ér véget, örök körforgásban marad. A fenti ciklus-szerkezet az ún. hátultesztelő ciklus, mivel a feltételt a ciklusmag végrehajtása után vizsgálja a gép. Lehetőség van ún. elöltesztelő ciklus készítésére is, amelyben a ciklusmag végrehajtása előtt vizsgálja a feltételt a gép: while (feltétel) utasítás-blokk A számlálós ciklust akkor használjuk, ha előre tudjuk, hogy egy utasítást (utasítás-blokkot) hányszor akarunk végrehajtani. A számlálós ciklus általános alakja a következő: for ( kifejezés1 ; kifejezés2 ; kifejezés3 ) utasítás-blokk A kifejezés1-ben állítjuk be a ciklusváltozó kezdő értékét, a kifejezés2-ben adjuk meg a ciklusmag végrehajtásának feltételét, ami a leggyakrabban egy logikai kifejezés, a kifejezés3-ban pedig léptetjük a ciklusváltozót. A számlálós ciklus elöl tesztel és a végén növel, azaz a ciklusmag végrehajtása előtt vizsgálja a kifejezés2-ben megadott feltételt és a ciklusmag végrehajtása után növeli meg a ciklusváltozó értékét (kifejezés3). Például az alábbi ciklus kiírja az első 9 pozitív egész számot. (Az i a ciklusváltozó.) for ( i=1 ; i<=9 ; i++ ) cout << i << endl ; Az adattípusokról bővebben A karakterekről részletesebben A char típus egyszerre jelent számot (8 bites, előjeles, -128.. 127) és karaktert. (ASCII táblázat szerint) A cout << a utasítás egy karaktert fog kiírni, a cout << int(a) utasítás pedig az ASCII kódját, mert az átalakítással számként kezelést kértünk. Szövegek tárolása: Az eredeti C nyelvben nincs külön adattípus a szövegek (stringek) tárolására, hanem karaktertömböket használnak erre a célra. A szöveg végét egy speciális karakter a \0 jelzi a tömbben. A C++ nyelvben bevezették a string típust, de ez is hasonlóképpen működik. char sz[]= C-nyelv vagy char sz[10] vagy string sz Amennyiben a fordítóprogram hibát jelez a string típus használatakor, használjuk a program elején az #include <string> direktívát! Szövegekkel kapcsolatos műveletek A szöveg hossza: s.length () A szöveg i-edik karaktere: s [i] Figyelem: a szöveg első karakterének indexe 0! A szöveg része: s.substr (kezdőindex, darabszám) Egy szövegben egy szövegrész kezdőindexe: s1.find (s2) Figyelem: ha nincs benne az s1 szövegben az s2 szövegrész, akkor bármit kaphatunk eredményül! Szövegek összefűzése: s1+s2 Amit a logikai típusról tudni érdemes A C nyelvben nincs logikai típus, erre a célra bármelyik sorszámozott alaptípus használható. A logikai igaz értéket az 1, a hamisat a 0 jelenti. Az operátorok közt vannak logikai jellegűek (például az összehasonlító operátorok), ezek mindig a fenti két érték valamelyikét szolgáltatják eredményül. Bevezetés a C++ programozásba (5/10. oldal)
Ugyanakkor azok az operátorok, illetve utasítások, amelyek logikai jellegű értéket várnak (például a feltételes elágazás), egy ennél tágabb értelmezést használnak: a 0 jelenti továbbra is a hamis logikai értéket, azonban minden más, nem 0 adatot igaznak fogadnak el. A C++ nyelvben már bevezették a logikai típust (bool), de itt is sokszor találkozunk a false==0 true ==1 jelenséggel. Változótömbök deklarációja: Típus tömbnév[méret] több dimenziós tömbök esetén: Típus tömbnév[méret1][méret2] A tömbök indexelése mindig 0-tól kezdődik! Új adattípusok definíciója Bonyolultabb szerkezetű adatok tárolásakor szükség lehet arra, hogy új adattípusokat definiáljunk. Ennek általános formája a következő: typedef típus típusnév Leginkább akkor van új típus definiálására szükség, ha különféle típusú elemi adatokat szeretnénk egyetlen változóban, vagy változótömbben tárolni. Ilyenkor ún. adatstruktúrát kell kialakítanunk. Például ha emberek nevét, életkorát és nemét szeretnénk tárolni, akkor létrehozhatjuk az ember nevű adattípust: typedef struct string nev; int kor; char nem; ember ; Ezután már használhatjuk az ember adattípust a változó-deklarációkban: ember szemely1, szemely2 ; ember szemelyek[20] ; Az adatstruktúra egyes elemeit, ún. mezőit a következő módon érhetjük el: szemely1.nev = "Kis Lajos" ; szemelyek[6].kor = 45 ; Az adatstruktúrák maguk is tartalmazhatnak további tömböket és adatstruktúrákat, így tetszőlegesen összetett adatszerkezeteket fel lehet építeni. Modulok és fejléc-fájlok (include) A C++ nyelv (a Pascalhoz hasonlóan) modulokból épül fel. Ez a gyakorlatban azt jelenti, hogy bizonyos utasításokat és adatszerkezeteket csak akkor használhatunk, ha a program elején feltüntetjük a megfelelő modul-fejlécet az include direktívával. Pl: A legfontosabb modulok a következők: <iostream> : kimenet, bemenet (cout, cin) <fstream> : fájlkezelés (ifstream, ofstream) <string> : szövegekkel kapcsolatos műveletek <cmath> : matematikai függvények ( sin(x), abs(x) ) <cstdlib> : véletlen szám (rand, srand) <ctime> : rendszeridő (time) Névterek (namespace) A névterek használata arra való, hogy ugyanazt a nevet használhassuk más-más kontextusban, más-más értelemben. Mi a standard (std) névteret fogjuk használni. Például a cout teljes neve std::cout, aminek az olvasata: a cout azonosító, amelyik az std névtérben van. A using namespace std azt eredményezi, hogy ezeket az std:: előtagokat nem kell kiírni. Bevezetés a C++ programozásba (6/10. oldal)
Adatbevitel és adatkivitel (Input / output) A forrás >> változó típusos olvasás, tehát a változó típusától függően működik. Például a cin >> változó utasítás mindig a változó típusának megfelelő mennyiségű adatot olvas be a bemenetről. Tehát a cin >> a >> b >> c utasítás egy sorban 3 egész számot olvas be, amelyek például szóköz karakterrel vannak elválasztva. A számok rendre az a, b, c változókba kerülnek. A cin >> sz utasítással vigyázni kell, ha szöveget akarunk beolvasni, ugyanis csak a szövegsor első szavát fogja beolvasni! (Az első szóköz vagy tab karakterig.) Helyette használjuk inkább a getline (cin, sz) utasítást! A getline(forrás, szövegesváltozó) típus nélküli olvasás, kizárólag szöveges változóba lehet így olvasni. Fájlkezelés A fájlok kezelése a C++ nyelvben két objektum-osztály használatával történik. Az ifstream osztállyal kezelhetjük a bemenő adatfájlokat (olvasás), az ofstream osztállyal a kimenő adatfájlokat (írás). Ezen osztályok használatához a program elején be kell illesztenünk a megfelelő fejléc-fájlt: # include <fstream> Fájlból olvasáshoz először is létre kell hozni egy bemenő adatfájl típusú fájlváltozót: (Pontosabban fogalmazva: létre kell hozni az ifstream osztály egy objektum-példányát.) ifstream fájlváltozó ; Ezután meg kell nyitni a fájlt. Ekkor történhet a fájlnév hozzárendelése a fájlváltozóhoz: fájlváltozó.open ( fájlnév ) ; Fájlból olvasni a standard beolvasáshoz hasonlóan lehet: fájlváltozó >> változó1 >> változó2 ; illetve: A fájl végének elérését az eof ( ) függvény hívásával ellenőrizhetjük: fájlváltozó.eof ( ) A fájl használatának befejeztével le kell zárni a fájlt: fájlváltozó.close ( ) ; getline(fájlváltozó, szöveges_változó) Fájlba íráshoz először is létre kell hozni egy kimenő adatfájl típusú fájlváltozót: (Pontosabban fogalmazva: létre kell hozni az ofstream osztály egy objektum-példányát.) ofstream fájlváltozó ; Ezután meg kell nyitni a fájlt. Ekkor történhet a fájlnév hozzárendelése a fájlváltozóhoz: fájlváltozó.open ( fájlnév ) ; Fájlba írni a standard kiíráshoz hasonlóan lehet: fájlváltozó << "szöveg" << "\n" << változó << endl ; A fájl használatának befejeztével le kell zárni a fájlt: fájlváltozó.close ( ) ; Létező fájlhoz hozzáírni (append) úgy lehet, hogy a kimenő adatfájlt a következőképp nyitjuk meg: fájlváltozó.open ( fájlnév, ios::app) ; Függvények használata A függvény nem más, mint a program egy önállóan működő része, amely a program egy részfeladatának elvégzéséért felelős. Egyszerűbb programokban nem szoktunk függvényeket használni, komolyabb programokban azonban fontossá válnak. Ennek két oka van: Bevezetés a C++ programozásba (7/10. oldal)
Egyrészt a program áttekinthetőbbé válik, ha az egyes részfeladatokat végző programrészletek világosan elkülönülnek egymástól. Másrészt függvények használatával elérhető, hogy egy programrészletet többször is felhasználjunk anélkül, hogy újra bele kellene írnunk a programba. Az alábbi példaprogram hatvanyoz nevű függvénye például természetes kitevőjű hatványozást végez: float hatvanyoz (float alap, int kitevo ) //ez a függvény ún. deklarációja //az alap és a kitevo a függvény paraméterei //itt kezdődik a függvény definíciója int i ; float x ; //i és x a függvény saját (lokális) változói x = 1 ; for (i=1 ; i<=kitevo ; i++) x *= alap ; return x ; //a függvény itt kapja meg az ún. visszatérési értékét int main() //itt kezdődik a főprogram float a ; int n ; cin >> a ; cin >> n ; cout << a << " szam " << n << " edik hatvanya: " << hatvanyoz (a,n) << endl ; return(0); A függvények kapcsán fontos kitérnünk a változók hatókörének kérdésére. A függvények belsejében deklarált változók a függvény saját, ún. lokális változói. Ezek a változók csak a függvény belsejében érvényesek, a függvényen kívül, például a főprogramban nem érhetők el. Mivel a C++ nyelvben a főprogram maga is egy függvény (int main ( )) ezért a főprogramban deklarált változók sem érhetők el a függvények belsejében. Hogyan adhat át adatokat a főprogram a függvényeknek és viszont: a függvények a főprogramnak? Erre a célra alapvetően a függvény paraméterei szolgálnak. Alapesetben a függvény a paraméterein keresztül kapja meg a működéséhez szükséges adatokat, az eredményt pedig az ún. visszatérési értékében adja vissza a főprogramnak. Ez történik a fenti példaprogramban is. A függvényeknek tetszőleges számú és típusú paraméterük lehet, és a visszatérési értékük is tetszőleges, akár összetett típusú is lehet. Készíthetünk olyan függvényt is, amelynek nincs visszatérési értéke. (Az ilyen alprogramokat eljárásnak is szokták nevezni.) Ebben az esetben a függvényt void típusúnak kell deklarálnunk, továbbá nem szerepelhet benne a return utasítás. Előfordulhat azonban, hogy egy függvény olyan feladatot végez a programon belül, amelynek során közvetlenül hozzá kell férnie a főprogramban használt változókhoz. Tipikus példa erre, ha egy függvény a háttértárról adatokat olvas be a memóriába. Ilyenkor a kérdéses változókat ún. globális változóként kell létrehozni. Ez azt jelenti, hogy a változót nem a main függvény definíciós részében, hanem azon kívül, a függvények definíciói előtt kell deklarálni. Pl: int x; void fuggveny () cout << x; int main( ) x=4; fuggveny(); //ez a globális változó Bevezetés a C++ programozásba (8/10. oldal)
return (0); Az operátorokról részletesebben A ++ és egyoperandusú műveletek, postfix és prefix alakban is írhatók. Ha egy kifejezésben csak egy változó szerepel, akkor mindegy, hogy a postfix, vagy a prefix alakját használjuk az operátoroknak, azaz a++ egyenértékű ++a-val. Ha azonban egy kifejezés kiértékelésében használjuk, akkor már óvatosabban kell bánni a két alakkal. Lássuk az alábbi példát: int a=4, x, y; x=++a; y=a++; A programrészletben az első értékadás előtt az a változó értéke 1-gyel nő így 5 lesz, ezt kapja az x változó, tehát annak értéke is 5 lesz. A második értékadásban az y megkapja a pillanatnyi értékét az ötöt, majd az a értéke 1-gyel nő, azaz 6 lesz. A bitenkénti operátorok operandusai csak char, short, int és long típusú előjel nélküli egészek lehetnek. A műveletek első csoportjába a bitenkénti logikai műveletek tartoznak: a & bitenkénti és, a bitenkénti vagy, a ^ bitenkénti kizáró vagy. Ezeket a műveleteket leggyakrabban maszkolásra, vagy bitek törlésére szoktuk használni. A kizáró vagy érdekes tulajdonsága, hogy ha ugyanazt a maszkot kétszer alkalmazzuk egy értékre, akkor visszakapjuk az eredeti értéket. A műveletek másik csoportjába a biteltoló műveletek tartoznak. << eltolás balra, >> eltolás jobbra. A felszabaduló pozíciókba 0 kerül, a kilépő bitek elvesznek. A műveletek két operandusúak. a<<2 az a változó bitjeit 2-vel tolja balra. Nyilvánvalóan az n bittel való balra tolás 2 n -nel való szorzást, míg az n bittel való jobbra tolás 2 n -nel való egész-osztást eredményez. Az értékadó operátorral már korábban megismerkedtünk. Az értékadás történhet a más nyelvekben megszokottak szerint. a=érték, vagy a=kifejezés formában Van azonban olyan forma is, mely a hagyományos nyelvektől teljesen idegen. b=2*(a=4)+5 Ebben az esetben az a és a b változó is kap értéket. Az értékadó operátor mindig jobbról balra értékelődik ki, tehát a kiértékelés után a fenti kifejezésben az a változó értéke 4, a b változó értéke pedig 13 lesz. A kiértékelés ilyen sorrendje miatt van az, hogy a C++ nyelvben az összetett értékadás is működik: a=b=c=0 értékadás után mindhárom változó értéke 0 lesz. Van az értékadásnak C++ nyelvben egy tömörebb formája is. Általános alakban a következőképpen írható le: változó = változó operátor kifejezés helyett a változó operátor = kifejezés Ez a forma általában gyorsabb kódot és áttekinthetőbb programszöveget eredményez. A C++ programokban természetesen mindkettő forma használható. A mellékelt táblázatban összefoglaljuk ezeket a rövidített értékadásokat. A feltételes operátor a C++ nyelvben az egyetlen operátor, melynek három operandusa van. Általános alakja a következő: Hagyományos forma a=a+b a=a-b a=a*b a=a/b a=a%b a=a<<b a=a>>b a=a&b a=a b a=a^b Tömör forma a+=b a-=b a*=b a/=b a%=b a<<=b a>>=b a&=b a =b a^=b Bevezetés a C++ programozásba (9/10. oldal)
kifejezés1? kifejezés2 : kifejezés3 Itt először a kifejezés1 értékelődik ki, ha ennek értéke nem 0, azaz IGAZ, akkor a kifejezés2 adja a feltételes kifejezés értékét, különben pedig a kifejezés3. A feltételes kifejezés típusa mindig a kifejezés2 és kifejezés3 típus közül a nagyobb pontosságú típusával egyezik meg. A következő példában a c változó értéke az a és b közül a kisebbel lesz egyenlő. c = a < b? a : b A C++ nyelvben kétfajta típuskonverzió (típusátalakítás) létezik, az implicit (automatikus) és az explicit. Az első a C++ nyelvbe rögzített szabályok szerint történik a programozó beavatkozása nélkül, a második pedig a típuskonverziós operátor segítségével. Ennek általános alakja: (típusnév) kifejezés Az implicit konverzióval kapcsolatban elmondhatjuk, hogy általában a szűkebb operandus információveszteség nélkül konvertálódik a szélesebb operandus típusára. int i,j; float f,m; m=i+f; Ebben az esetben az i float-ra konvertálódik. j=i+f; Itt viszont vigyáznunk kell, mert adatvesztés lép fel, az összeg törtrésze elveszik! Explicit konverziót kell végrehajtanunk a következő példában, ha f-be nemcsak az egész osztás hányadosát szeretnénk betenni int a = 12, b = 5; float f; f = (float) a / (float) b; A C++ nyelvben használt operátorokat foglalja össze az alábbi táblázat: Operátor Jelentés + * / Szokásos matematikai; az osztás maradékos is lehet! ++ Növelés / csökkentés 1-gyel % Osztási maradék << >> Bitenkénti eltolás balra / jobbra < <= > >= Relációs jelek = =!= Egyenlő, nem egyenlő & Bitenkénti és ^ Bitenkénti kizáró vagy Bitenkénti vagy! Logikai nem && Logikai és Logikai vagy = Értékadás += -= *= /= %= Érték megváltoztatása Pl: a += b Hagyományos formában: a = a + b?: Feltételes értékadás Pl: c = a < b? a : b Hagyományosan: if ( a < b ) c = a else c = b ; Bevezetés a C++ programozásba (10/10. oldal)