Tartalom... 2 Bevezetés UNIX gyorstalpaló [labor] Bejelentkezés stty... 5 erase, kill, intr, echo... 6 raw és cooked...

Átírás

1 Pohl László C++ gyak. és labor jegyzet BME 2006

2 Tartalom Tartalom... 2 Bevezetés UNIX gyorstalpaló [labor] Bejelentkezés stty... 5 erase, kill, intr, echo... 6 raw és cooked... 6 fontos Alapvető parancsok Integrált fejlesztőkörnyezet [labor] C ismétlés [gyakorlat] Feladat Feladat Feladat feladat feladat Const, referencia, string [labor] Const Referencia String Vándorlás C-ről C++-ra [gyakorlat] C++ kiírás Mutatók, tömbök, referenciák Változók Swap Függvények cin, cout, cerr Kivétel Stack, névtér, kivétel Osztályok és operátorok [gyakorlat] Osztály struct-ból Osztály Objektumok és szorzás Szorzás valóssal Abszolút érték Házi feladat Osztály class-ból Osztály Konstruktor Egyenlőségjel operátor Kiírás és beolvasás Nem inline tagfüggvény Konstruktorok összevonása Házi feladat String osztály [labor] Feladatok string_class_h.cpp

3 string2.cpp Dinamikus adattagokat tartalmazó osztályok [gyakorlat] komplex szám tárolására alkalmas tömb Diákok adatai példa Gyakorló feladatok: Öröklés Ablakok IOSTREAM F Hivatkozások

4 Bevezetés Ez a jegyzet azokat a gyakorlati ismereteket kívánja bemutatni, melyek a C++ programozás tanulása során felmerülnek, és a tárgy tematikának részei. A C++ nyelvet, hasonlóan a beszélt nyelvekhez, nem lehet elsajátítani önálló tanulás nélkül, ezért mindenképpen oldjunk meg gyakorló feladatokat óráról órára, egyedül, otthon! A példaprogramokat nem kell begépelni. A jegyzet elektronikus formában a oldalon megtalálható, a pdf-ből ki lehet másolni a szöveget, ha az Adobe Reader felső eszköztárán a Select Text-et választjuk, de a példaprogramok zip-elve is letölthetők ugyanonnan, így még a formázás is megmarad. A jegyzettel kapcsolatos kritikákat, hibalistákat a pohl@eet.bme.hu címre várom. 4

5 1. UNIX gyorstalpaló [labor] A félév során végig C++-szal fogunk foglalkozni, de bevezetésképp nagyon röviden megismerkedünk a UNIX legfontosabb parancsaival. Irodalom: [1,2,3] Bejelentkezés Az Ural2 szerveren futó UNIX használatához témaszámra van szükség, mely a megfelelő operátori fülkékben átvehető. A számítógépen indítsuk el a Windowst, innen a putty.exe terminál programmal tudunk bejelentkezni az Ural2-re. Az Ural2 eléréséhez használjuk az SSH módot (1.1. ábra)! 1.1. ábra: A putty terminál konfigurációs képernyője Ha helyesen töltöttük ki a konfigurációs adatokat, és az Open gombra kattintunk, egy szöveges terminál ablak jelenik meg. Itt először meg kell adni azonosítónkat és jelszavunkat. Ha először jelentkezünk be, a rendszer új jelszót kér. A jelszó legalább 6 karakter legyen, és tartalmazzon legalább egy számjegyet és két betűt az első hat karakterében. Ha sikeresen bejelentkeztünk, kapunk néhány tájékoztató üzenetet, és megjelenik a prompt. Ide írhatjuk a parancsokat. Figyeljünk arra, hogy a UNIX érzékeny a kis- és nagybetűk megkülönböztetésére! 1.2. stty Azaz set teleltype. Írjuk be, hogy stty -a Ennek hatására megjelennek a konzol beállításai. Pl.: speed 9600 baud; line = 1; intr = ^C; quit = ^\; erase = DEL; kill = ^U; eof = ^D; eol <undef>; swtch = ^Z lnext = ^V; werase = ^W; rprnt = ^R; flush = ^O; stop = ^S; start = ^Q -parenb -parodd cs8 -cstopb hupcl cread clocal -loblk -tostop -ignbrk brkint ignpar -parmrk -inpck istrip -inlcr -igncr icrnl -iuclc 5

6 ixon -ixany -ixoff isig icanon -xcase echo echoe echok -echonl -noflsh opost -olcuc onlcr -ocrnl -onocr -onlret -ofill -ofdel tab3 Ezek közül csak néhánnyal foglalkozunk. erase, kill, intr, echo Alapértelmezés szerint általában az stty erase DEL szerepel, vagyis a DEL billentyűvel törölhetünk. Ha a # billentyűvel szeretnénk törölni, írjuk ezt: stty erase #! Ha ki akarjuk törölni a parancssorba eddig begépelt összes szöveget, a kill funkciót használjuk. A fenti esetben ez ^U, azaz Ctrl+U. Ha ki akarunk lépni egy futó programból, az intr funkciót használjuk, ami általában Ctrl+C. stty echo, stty echo: az elsőt beállítva a leütött billentlyűk megjelennek a képernyőn, a második esetben (--szal) nem, ilyenkor tehát vakon kell gépelnünk. raw és cooked stty raw, vagy stty -cooked esetén nem dolgozza fel a rendszer a vezérlő karaktereket (pl. a kill, erase stb.-t sem), stty raw vagy stty cooked esetén feldolgozza. További részletetek: ill. man parancs. fontos A bash raw módot kapcsol, ezért valójában a kill és az erase nem az, amit beállítunk. Viszont ha egy programot elindítunk (pl. cat), már az stty-nal beállított értékek vannak érvényben. 1.3 Alapvető parancsok További parancsokért, illetve a parancsok további beállításaiért lásd [1,2,3]. man A UNIX elektronikus kézikönyvében (manual) kereshetünk vele. ls Kilistázza a mappa tartalmát. Néhány kapcsolója: -a: minden állományt listáz -l: részletes adatokat közöl az állományokról -r: fordított sorrendben listáz -t: időrendben listáz A kapcsolókat össze is vonhatjuk. Pl.: ls alrt. cat Összefűzi a paraméterként kapott fájlokat, és kiírja azokat a standard kimenetre. Ha nem írunk paramétert, vagy --t írunk, a standard bemenetről olvas EOF-ig. (Az EOF-ot is beállíthatjuk a stty-nal). Fájl kiírása a képernyőre: cat fajlnev Két fájl összefűzése: cat fajlnev1 fajlnev2 > fajlnev3 Az eredmény a fajlnev3-ba kerül. 6

7 echo A paraméterként kapott szöveget megjeleníti a standard outputon. cd Change directory: mappaváltás. cd.. : egy mappával feljebb cd / : a gyökérbe cd mappanev : a mappanev nevű mappába pwd Print working directory: kiírja a munkamappa (az aktuálisan használt mappa) nevét. passwd Új jelszót adhatunk meg. rm, rmdir Fájl ill. mappa eltávolítására. rm * : kitörli az aktuális mappából az összes fájlt. (Vigyázat, nincs kuka, ahonnan visszaállítsuk!) mkdir Új mappa létrehozása. mv Fájl mozgatása vagy átnevezése. more Fájl kiírása a standard outputra. cp Fájl másolása. -r vagy R: rekurzív másolás, azaz ha a forrás mappa, annak tartalmát a célmappába másolja chmod Fájl vagy mappa védelmi kódjának módosítása. Csak a tulajdonos, vagy rendszergazda változtathatja. chmod g-rwx fájlnév : megtiltja az írást, olvasást és végrehajtást a csoporttársaknak chmod 0764 fájlnév : a tulajdonos írhat, olvashat, végrehajthat, a csoporttagok olvashatnak és írhatnak, a többi felhasználó csak olvashat. Feladat: ln Link vagy szimbolikus link létrehozása. ln forrasfajl ujnev : létrehozza az ujnev nevű linket forrásfájlra. A kettőnek fizikailag azonos disken kell lennie. ln s forrasfajl ujnev : létrehozza az ujnev nevű szimbolikus linket forrásfájlra. A kettőnek nem kell fizikailag azonos disken lennie. df Display free disk space du Disk usage. Feladatok: A haladók megpróbálhatják első szorgalmi házijukat elérni. Fájlok feltöltésére jól használható a WinSCP nevű program, melyben commanderhez hasonlóan tudunk fájlokat másolni. 7

8 2. Integrált fejlesztőkörnyezet [labor] A laboron tetszőleges korszerű C++ fordító használható (a borland C++ nem ilyen). A jegyzetben a Visual C++.NET 2003-mal találkozhatunk majd. Ebben kicsit másképpen kell létrehozni a Console Application projektjét. 1. lépés: 2. lépés: 3. lépés: 8

9 4. lépés: 5. lépés: 9

10 3. C ismétlés [gyakorlat] 3.1. Feladat Készítse el a Hello Világ! programot szabványos C nyelven, pontosvessző használata nélkül! 3.2. Feladat Készítsen szabványos C programot, mely a paraméterként kapott szöveges fájlt olyan formában írja a képernyőre, hogy csak a magánhangzók, és a soremelések maradnak a helyükön, az összes többi helyett szóköz jelenjen meg! Egy megoldás: #include <stdio.h> #include <stdlib.h> void error(const char * s){ printf("%s",s); exit(-1); void main(int argc,char ** argv){ int c; FILE * fp; if(argc<2)error("tul keves parameter, inditaskor adja meg a hivando fajl nevet!"); if((fp=fopen(argv[1],"rt"))==null)error("nem tudom megnyitni a fajlt"); while((c=getc(fp))!=eof){ switch(toupper(c)){ case 'A': case 'E': case 'I': case 'O': case 'U': case '\n':fprintf(stdout,"%c",c);break; default: fputc(' ',stdout); A programban nem használtuk a feof() függvényt, mert utólag működik, ami azt jelenti, hogy akkor jelzi, hogy a fájl végére értünk, ha már egy művelet sikertelen volt. Emiatt jobban járunk, ha a művelet sikertelenségére figyelünk. Beolvasásnál használhattuk volna a fscanf() függvényt is, ebben az esetben nem azt nézzük, hogy a visszatérési érték egyenlő-e az EOF konstanssal, mert sohasem lesz egyenlő, hanem azt, hogy a visszatérési érték megegyezik-e a beolvasni kívánt változók számával Feladat a) Írjon függvényt, mely kiszámítja két egész szám összegét és négyzetösszegét! b) Írjon programot, mely egészekből álló számpárokat olvas a standard inputról, meghívja a fenti függvényt, kiírja az összeget és négyzetösszeget, egész addig, míg az egyik beolvasott szám 0 nem lesz. Nem használhat globális változókat! Egy megoldás: 10

11 #include <stdio.h> #include <stdlib.h> void osszegzo(int a,int b,int * sum,int * nsum){ *sum=a+b; *nsum=a*a+b*b; void error(const char * s){ printf("%s",s); exit(-1); void main(){ int a,b,s,ns; fflush(stdin); if(scanf("%d %d",&a,&b)!=2)error("sikertelen beolvasas"); while(a!=0&&b!=0){ osszegzo(a,b,&s,&ns); printf("ossz=%d\tnegyzetossz=%d\n",s,ns); fflush(stdin); if(scanf("%d %d",&a,&b)!=2)error("sikertelen beolvasas"); Olvassuk el a C jegyzet fejezetében a veremkezelésről szóló részt! Mi történik, ha lemarad az & jel a függvényhívásnál? 3.4. feladat Írjon függvényt, mely kiszámítja két, paraméterként kapott double típusú szám szorzatát! Írjon függvényt, mely kiszámítja két, paraméterként kapott, stringként megadott valós szám szorzatát, és az eredményt egy paraméterként kapott karaktertömbben adja vissza! Egy megoldás: void mul(const char * a,const char * b,char * c){ double d1=0,d2=0,d3; sscanf(a,"%lg",&d1); sscanf(b,"%lg",&d2); d3=d1*d2; sprintf(c,"%g",d3); 3.5. feladat Írjon programot, mely tartalmaz egy struktúra típust: struct String{ char * p; int len; ; Készítsen függvényt, mely összefűz két ilyen Stringet visszaadja a String valahányadik karakterét (azaz indexeli) létrehoz egy ilyen típusú változót egy char * típusú stringből létrehoz egy ilyen típusú változót egy karakterből 11

12 kiír egy ilyen Stringet kitörli a paraméterként kapott Stringből a dinamikus tömböt Készítsen main függvényt, melyben ezt kipróbálja! Nem használhat globális változókat! Egy megoldás: #include <stdio.h> #include <stdlib.h> #include <string.h> struct String{ char * p; int len; ; void error(const char * s){ printf("%s",s); exit(-1); String osszefuz(const String a,const String b){ String c; int n=a.len+b.len+1; c.len=n-1; c.p=(char *)malloc(n*sizeof(char));//a sizeof(char) definíció szerint 1 if(c.p==null)error("osszefuz -> Memoriafogalalas nem sikerult!"); for(int i=0;i<a.len;i++)c.p[i]=a.p[i]; for(int i=0;i<b.len;i++)c.p[i+a.len]=b.p[i]; c.p[c.len]=0; return c; char index(const String s,const int n){ return (n>=0&&n<s.len)?s.p[n]:0; String letrehoz1(const char * s){ String a; a.len=strlen(s); a.p=(char*)malloc(a.len+1);// most nem írjuk ide a sizeof-ot if(a.p==null)error("letrehoz1 -> Memoriafogalalas nem sikerult!"); strcpy(a.p,s); return a; String letrehoz2(const char c){ String a; a.len=1; a.p=(char*)malloc(2);// most nem írjuk ide a sizeof-ot if(a.p==null)error("letrehoz2 -> Memoriafogalalas nem sikerult!"); a.p[0]=c; a.p[1]=0; return a; 12

13 void kiir(const String s){ printf("%s",s.p); void torol(string * s){ free(s->p); s->p=null; s->len=0; void main(){ String a=letrehoz1("sikerult "); String b=letrehoz2('a'); String c=letrehoz1(" letrehozas"); String d=osszefuz(a,b); String e=osszefuz(d,c); kiir(e); torol(&a); torol(&b); torol(&c); torol(&d); torol(&e); Ebben a programban már használtunk néhány C++ elemet. C++-ban a struktúra (és az enumé is) neve típusnak számít, tehát ezzel közvetlenül létre lehet hozni ilyen változót (pl. nem kellett odaírni a main()-ben, hogy struct String a). A másik: C++-ban bárhol lehet definiálni változót, ahol egyébként utasítás állhat, tehát nem csak blokk elején. Pl.: for(int i=0;i<a.len;i++)c.p[i]=a.p[i]; A szabványos C++-ban a for fejében definiált i változó lokális a for ciklusra nézve, tehát azon kívül nem látszik, ezért szerepelhet a következő sorban egy ugyanolyan definíció. Figyelem! A Visual C++ 6-ban ez nem igaz, ott az így definiált i később is látszik. A későbbi Visual C++ fordítók már elfogadják a szabványos felépítést is, meg a korábbiból örököltet is, ami annyit jelent, hogy a szabványosan megírt program is lefordul, nem szól amiatt, hogy a változót újradefiniáltuk volna, viszont a változó a for cikluson kívül is elérhető marad, ami sajnos egy hibalehetőség. 13

14 4. Const, referencia, string [labor] 4.1. Const Töltsük le Szeberényi tanár úr oldaláról a fájlt!: // // Állapítsa meg, hogy milyen hibák vannak az alábbi C++ állományban! // Magyarázza meg, hogy az egyes számozott programrészekben mi miért hiba! // Ha valameyik részben nicsn hiba, akkor azt is indokolja! // // 0. void ff(const int *ip) { *ip = 3; int main(){ // 1. const int i; // 2. const int j = 10; j++; // 3. const int l = 10; int *p=&l; (*p)++; // 4. extern void f(int *i); const int iv = 100; f(&iv); // 5. const int ivv = 100; ff(&ivv); // 6. const int v[] = {1,2,3; v[1]++; // 7. const int siz = 20; int t[siz]; // 8. char s1[] = "Hello konstans szoveg"; const char *pc = s1; pc[0] = 'A'; pc++; // 9. char s2[] = "Hello konstans pointer"; char* const cp = s2; cp[0] = 'B'; cp++; // 10. char s3[] = "Hello konstans szoveg konstans pointer"; const char* const cpc = s2; cpc[0] = 'C'; cpc++; // 11. enum Szinek { tok, zold, makk, piros ; Szinek adu; 14

15 adu = 1; adu = Szinek(10); return(0); Találjuk ki, hogy mely sorok hibásak, és miért? Lehetőleg első körben ne használjuk a fordító segítségét! 4.2. Referencia Töltsük le Szeberényi tanár úr oldaláról a fájlt!: // // Állapítsa meg, hogy milyen hibák vannak az alábbi C++ állományban! // Magyarázza meg, hogy az egyes számozott programrészekben mi miért hiba! // Ha valameyik részben nicsn hiba, akkor azt is indokolja! // // 1. long glob; float fglob; // 2. long& fr(){ return glob; // 3. int& fifi(){ int a; return a; // 4. int *fp(){ int a; return &a; // 5. long& fr(long x){ return x; // 6. long& fr(long& a){ return a; // 7. float& fr(long x){ return fglob; // 8. int szg(int a = 1, float x){ return a * x; // 9. int main(){ fr()++; fr() = 54; fr() = fr() + 4; return 0; 15

16 Találjuk ki, hogy mely sorok hibásak, és miért? Lehetőleg első körben ne használjuk a fordító segítségét! 4.3. String Töltsük le Szeberényi tanár úr oldaláról a fájlt!: // // Egészitse ki az alábbi C programot a megfelelő helyeken úgy // hogy az működőképes legyen! // #include <stdio.h> #include <malloc.h> #include <string.h> // Kiiratáshoz // Dinamikus memóriakezeléshez // Stringműveletekhez // A string struktúránk. // A 'p'-ben vannak a karakterek (a lezáró nullával együtt), 'len' a hossza. // (A lezáró nulla léte vagy hiánya implementációs kérdés). struct String { char *p; // pointer az adatra int len; // hossz lezaró nulla nélkül ; // Stringet készít egy karakterből struct String createfromchar(char ch) { struct String temp; // Meghatározzuk a hosszát temp.len = 1; // Lefoglaljuk a helyet + a lezaro nulla helyet temp.p = (char*)malloc(temp.len+1); // if (temp.p == NULL)... mi tegyunk? Nagyvonaluan elhagyjuk a vizsgálatot // Betesszuk a karaktert temp.p[0] = ch; temp.p[1] = '\0'; return temp; // Stringet készít egy karaktertömbből. struct String createfromchararray(char p[]) { struct String temp; // Meghatározzuk a hosszát #error hossz // Helyet foglalunk #error foglal // Bemásoljuk #error masol return temp; // Stringet készít egy Stringból struct String createfromstring(struct String s) { struct String temp; #error ezt kell megirni return temp; // Két stringet fűz össze, eredményét egy harmadikba írja. struct String concat(struct String a, struct String b) { struct String temp; 16

17 #error ezt kell megirni return temp; // A string egy megadott indexű elemével tér vissza. // Ha az index a [0..hossz-1] tartományon kívül van, '\0' karakterrel tér vissza. char index(struct String str, int index) { #error ezt kell megirni // Hozzáad egy karaktert a stringhez void addchar(struct String *str, char ch) { // Növeljük a helyet: régi karakterek + új karakter + lezáró nulla str->p = (char*)realloc(str->p, str->len + 2); // if (temp.p == NULL)... mi tegyunk? Nagyvonaluan elhagyjuk a vizsgálatot // A megnövelt helyre beírjuk az új karaktert és a lezáró nullát. *(str->p + str->len) = ch; *(str->p + str->len + 1) = '\0'; // Megnöveljük a hosszt. str->len++; // Kiírunk egy stringet void print(struct String str) { printf("%s", str.p); // Kiírunk egy stringet (debug célokra) void print_dbg(struct String str) { printf("[%d], %s\n", str.len, str.p); // Ha dinamikus memóriát használunk, gondoskodni kell a felszabadításról is. void dispose(struct String str) { free(str.p); int main() { struct String a,b,c,d, e; a = createfromchar('x'); print_dbg(a); b = createfromchararray("alma"); print_dbg(b); c = concat(a, b); print_dbg(c); d = concat(b, c); print_dbg(d); e = createfromstring(d); print_dbg(e); printf("%c\n", index(d, 4)); if (index(d, 100) == '\0') printf("hibas indexeles\n"); addchar(&d, 'a'); print_dbg(d); addchar(&d, 'b'); print_dbg(d); addchar(&d, 'c'); print_dbg(d); dispose(a); dispose(b); dispose(c); dispose(d); dispose(e); return 0; Egészítse ki ezt a C programot, hogy működőképes legyen! (a #errorok törlendőek). Készítse el a program C++ változatát! A struct név típus értékű. Memóriafoglalás és felszabadítás operátorral (new, delete), realloc kerülendő! Minden createfrom fv. helyett az overloaded create() függvény használandó. 17

18 Próbáljuk ki a kivételkezelést a string1.cpp program felhasználásával! Ehhez használhatjuk a UNIX-ot is: g++ -DBAD -o string1 sring1.cpp bash ulimit -d 1000./string1 exit 18

19 5. Vándorlás C-ről C++-ra [gyakorlat] A bemutatott példák részben [4]-ből származnak C++ kiírás Írjunk programot, amely kiírja az a.. z betűket és a számjegyeket, valamint a hozzájuk tartozó egész értékeket. Írjuk ki a hozzájuk tartozó egész értékeket hexadecimális alakban is! #include <iostream> #include <iomanip> using namespace std; void main(){ for(char i='0';i<='9';i++) cout << i << '\t' << int(i) << endl; for(char i='a';i<='z';i++) cout << i << '\t' << int(i) << endl; cout.setf(std::ios_base::showbase); cout.fill(' '); for(char i='0';i<='9';i++) cout << i << setw(12) << dec << int(i) << setw(12) << hex << int(i) << endl; for(char i='a';i<='z';i++) cout << i << setw(12) << dec << int(i) << setw(12) << hex << int(i) << endl; Az első változat egyszerű, a cout-ra küldjük a kiírandó változókat. A második esetben azonban formázást is használunk. A cout.setf(std::ios_base::showbase); azt állítja be, hogy hexadecimális vagy oktális esetben a kimeneten jelenjenek meg a számrendszerre utaló karakterek is a kiírt szám előtt, azaz 0x hexa esetben, és 0 oktális esetben. A cout.fill(' '); azt mondja meg, hogy mivel legyenek kitöltve a mező üresen maradt karakterei. A setw(12) az utána kiírt adat szélességét 12 mezőre állítja, az üres helyeket a fenti fill karakterrel (most szóközzel) tölti ki. A dec ill. a hex azt írja elő, hogy az utána következő egész számok kiírása az adott számrendszerben történjen. Az endl nem csak a soremelés karaktert írja ki, hanem üríti a kimeneti puffert, azaz az eddig kiírtak biztosan megjelennek a standard outputon Mutatók, tömbök, referenciák Változók Hozzunk létre változókat, mindegyiknek adjunk kezdőértéket is!: a) Karakterre hivatkozó mutató b) 10 egészből álló tömb c) 10 egészből álló tömb referenciája d) Karakterláncokból álló tömbre hivatkozó mutató e) Karakterre hivatkozó mutatóra hivatkozó mutató f) konstans egész 19

20 g) konstans egészre hivatkozó mutató h) egészre hivatkozó konstans mutató void main(){ //a) char c='x'; char * p=&c; //b) int t[]={1,2,3,4,5,6,7,8,9,10; //c) int (&rt)[10]=t; //d) char * st[5]; char * (*pst)[5]=&st; //e) char ** ppc=&p; //f) const int k=0; //g) const int * pk=&k; //h) int i=100; int * const cpi=&i; Swap Írjunk egy swap nevű függvényt, amely két egészet cserél fel. Használjunk int* típust a paraméterek típusaként. Írjunk egy másik swap-et is, melynek paraméterei int& típusúak. #include <iostream> inline void swap(int * a,int * b){ int t=*a; *a=*b; *b=t; inline void swap(int & a,int & b){ int t=a; a=b; b=t; void main(){ int x=1; int y=3; swap(&x,&y); swap(x,y); 5.3. Függvények Deklaráljuk a következőket: a) Függvényt, melynek egy karakterre hivatkozó mutató, és egy egészre mutató referencia paramétere van, és nem ad vissza értéket. b) Ilyen függvényre hivatkozó mutató. c) Függvény, melynek ilyen mutató paramétere van. d) Függvény, mely ilyen mutatót ad vissza. e) Írjuk meg azt a függvényt, amelynek egy ilyen mutatójú paramétere van, és visszatérési értékként paraméterét adja vissza. //a) typedef void fvt(char*,int&); 20

21 //b) typedef fvt * pfvt; //c) void fv1(pfvt); //d) pfvt fv2(); //e) pfvt fv3(pfvt p){return p; void main(){ 5.4. cin, cout, cerr Íjunk titkosító programot, ami a cin-ről olvas, és a kódolt karaktereket kiírja a cout-ra. Használjuk a következő, egyszerű titkosító sémát: c karakter titkosított formája legyen c^key[i], ahol key egy karakterlánc, amely parancssori paraméterként adott. A program ciklikus módon használja a key-ben lévő karaktereket, amíg a teljes bemenetet el nem olvasta. Ha nincs megadva a key (vagy a paraméter null karakterlánc), a program ne végezzen titkosítást. Írja ki a titkosítatlan szöveget a cerr-re. #include <iostream> using namespace std; void main(int argc,char ** argv){ char c; bool kodole=argc>1&&argv[1][0]!=0; char * key=kodole?argv[1]:0; int i=0; while(cin.get(c)){ if(c=='\n')break; if(kodole){ if(key[i]==0)i=0; cout<<char(c^key[i]); else cout<<c; cerr.put(c); // << c is lehetett volna 5.5. Kivétel Példaprogram, melyben ha a fv() függvényt true paraméterrel hívjuk, kivetel típusú kivételt vált ki, ha false paraméterrel hívjuk. akkor bad_alloc-ot. #include <iostream> using namespace std; struct kivetel{; void fv(bool x){ int n=1024*1024*256; if(x)throw kivetel(); int * a=new int[n]; int * b=new int[n]; int * c=new int[n]; int * d=new int[n]; for(int i=0;i<1024;i++)a[i]=0; for(int i=0;i<1024;i++)b[i]=0; for(int i=0;i<1024;i++)c[i]=0; for(int i=0;i<1024;i++)d[i]=0; 21

22 delete [] a; delete [] b; delete [] c; delete [] d; void main(){ try{ fv(false); catch(bad_alloc){ cerr<<"bad alloc"<<endl; catch(kivetel){ cerr<<"kivetel"<<endl; 5.6. Stack, névtér, kivétel Helyezze el a MyStack névtérbe a Stack struktúrát, valamint a verem kezeléséhez szükséges függvényeket (push, pop, init, done). A verem karakterek tárolására legyen alkalmas. Készítse el a függvényeket, a hibák kezelését kivételekkel oldja meg! #include <iostream> using namespace std; namespace MyStack{ struct Stack{ char * p; int size; int elemszam; ; struct Overflow{; struct Underflow{; Stack init(const unsigned n){ Stack s; s.elemszam=0; s.size=n; s.p=new char[n]; return s; void done(stack & s){ delete [] s.p; s.elemszam=s.size=0; char pop(stack & s){ if(s.elemszam==0)throw Underflow(); return s.p[--s.elemszam]; void push(stack & s,const char c){ if(s.elemszam>=s.size)throw Overflow(); s.p[s.elemszam++]=c; void main(){ MyStack::Stack s=mystack::init(20); try{ for(char c='a';c<'z';c++){ MyStack::push(s,c); cout << c << "\tpushed" << endl; catch(mystack::overflow){ 22

23 cerr << "\noverflow" << endl; catch(mystack::underflow){ cerr << "\nunderflow" << endl; cout << endl; try{ while(1){ cout << MyStack::pop(s) << "\tpopped" << endl; catch(mystack::overflow){ cerr << "\noverflow" << endl; catch(mystack::underflow){ cerr << "\nunderflow" << endl; MyStack::done(s); 23

24 6. Osztályok és operátorok [gyakorlat] 6.1. Osztály struct-ból Osztály Készítsünk komplex számok tárolására alkalmas osztályt! struct complex_1{ double im,re; ; Íme Objektumok és szorzás Hozzunk létre három ilyen komplex szám objektumot, kettőnek adjunk kezdőértéket, és tegyük a harmadikba a kettő szorzatát, majd írjuk ki a standard outra! void main(){ // complex_1 complex_1 a1,b1,c1; a1.re=3.3; a1.im=0.0; b1.re=-5.1; b1.im=0.3; c1.re=a1.re*b1.re-a1.im*b1.im; c1.im=a1.im*b1.re+a1.re*b1.im; cout << "a1=" << a1.re << ',' << a1.im << 'i' << endl; cout << "b1=" << b1.re << ',' << b1.im << 'i' << endl; cout << "c1=" << c1.re << ',' << c1.im << 'i' << endl; Ebben semmi új nincs eddig. Látható, hogy elég hosszú kódot kellett írnunk. Első lépésben a szorzást helyettesítsük függvényhívással. Ehhez készítsük el a mul függvényt! complex_1 mul(const complex_1 a,const complex_1 b){ complex_1 c; c.re=a.re*b.re-a.im*b.im; c.im=a.im*b.re+a.re*b.im; return c; Ha a paramétereket konstansként adjuk meg, akkor nem fordulhat elő, hogy véletlenül valamit felülírunk, és elképzelhető, hogy a fordító hatékonyabb kódot hoz létre. A mul függvény paraméterként két darab komplex szám objektumot kap. Egy ilyen objektum 16 bájt méretű, mert két darab nyolcbájtos double számot tartalmaz. Lehet-e csökkenteni az adatforgalmat? Igen, ha nem érték szerint adjuk át a paramétert, hanem cím szerint, vagyis referenciával. Még gyorsabbá tehetjük a kódot, ha inline függvényt használunk. Ehhez nem kell mást tenni, mint a függvény neve elé írni, hogy inline. inline complex_1 mulr(const complex_1 & a,const complex_1 & b){ complex_1 c; c.re=a.re*b.re-a.im*b.im; 24

25 c.im=a.im*b.re+a.re*b.im; return c; Lehetne a visszatérési érték is referencia? Így nem, hiszen c lokális változó. A fenti két függvény használata: // szorzás függvénnyel complex_1 d1; d1=mul(a1,b1); cout << "d1=" << d1.re << ',' << d1.im << 'i' << endl; // szorzás referencia faraméter, inline függvény complex_1 e1; e1=mulr(a1,b1); cout << "e1=" << e1.re << ',' << e1.im << 'i' << endl; De ez a szorzás még nem az igazi. Az igazi az volna, ha megtehetnénk, hogy így írjuk fel a szorzást: e1=a1*b1;. Van erre lehetőség? Igen, a C++ nyelvben lehetséges az operátorok túlterhelése: inline complex_1 operator * (const complex_1 a,const complex_1 b){ complex_1 c; c.re=a.re*b.re-a.im*b.im; c.im=a.im*b.re+a.re*b.im; return c; Mely operátorok terhelhetők túl? Majdnem az összes, beleértve pl. a new-t, és a delete-t is. Egyszerűbb azokat felsorolni, amelyek nem terhelhetők túl: :: hatókör operátor. tagkiválasztás.* tagkiválasztás a tagra hivatkozó mutatón keresztül?: sizeof typeid Csak a meglévő operátorok használhatók, újat nem hozhatunk létre (azaz pl. nem gyárthatunk >>> operátort stb.). A 2-es pontban látni fogjuk, hogy ezt az operátort megvalósíthattuk volna tagfüggvényként is. Az operátor függvény paraméterei közül az első az operátor bal oldalán szereplő, a második a jobb oldalán szereplő változót jelenti. A paraméterek legalább egyike saját típus kell legyen, hiszen az alaptípusokhoz tartozó operátorok már definiálva vannak (pl. két double szorzása). // a * operátor túlterhelése complex_1 f1; f1=a1*b1; cout << "f1=" << f1.re << ',' << f1.im << 'i' << endl; f1=operator*(a1,b1); // így nincs értelme az operátort használni, de lehet 25

26 Szorzás valóssal Mi a helyzet akkor, ha nem két komplex számot akarunk összeszorozni, hanem egy komplexet egy valóssal? Akkor ezekhez a szorzásokhoz is el kell készíteni a megfelelő operátor függvényeket (vagy megfelelő típuskonverziós konstruktort kell írni, de erről később). inline complex_1 operator * (const complex_1 & a,const double b){ complex_1 c; c.re=a.re*b; c.im=a.im*b; return c; inline complex_1 operator * (const double a,const complex_1 & b){ complex_1 c; c.re=a*b.re; c.im=a*b.im; return c; Figyeljük meg, hogy a double típusra nem használtuk a & referencia operátort. Miért? Mert az alaptípusnál gyakran előfordul, hogy konstanssal adjuk meg, pl.: // valóssal szorzás complex_1 g1,h1; g1=2.8*b1; cout << "g1=" << g1.re << ',' << g1.im << 'i' << endl; h1=b1*2.8; cout << "h1=" << h1.re << ',' << h1.im << 'i' << endl; Ez saját osztályainknál nyilván nem fordul elő Abszolút érték Készítsünk abszolút értéket számító globális függvényt és tagfüggvényt! A globális függvény így néz ki: inline double abs(const complex_1 c){ return sqrt(c.re*c.re+c.im*c.im); Természetesen az inline elhagyható. A tagfüggvényként történő megvalósítás egy teljesen új elem az eddig tanultakhoz képest. A tagfüggvény az osztályon belül kerül megvalósításra, ehhez tehát a következőképpen egészítjük ki a complex_1 osztályt: struct complex_1{ double im,re; ; double abs()const{return sqrt(im*im+re*re); A következő dolgokat vehetjük észre: A függvény nem kap paramétert, mert a struktúra adattagjaival dolgozik. 26

27 A () után szerepel a const szó. Ezzel azt jelezzük, hogy a függvény nem bántja a struktúra adattagjait, csak olvassa őket. Akkor sincs probléma, ha ezt elfelejtenénk odaírni. Az im és re adattagok a függvény számára olyanok, mintha globális változók lennének, tehát nem valami.im ill. valami.re-ként hivatkozunk rájuk. A struktúrán belül írtuk az abs függvény kódját. Ezt külön is lehet, később majd látjuk, hogyan. Ha így, a struktúrán belül adjuk meg, a függvény inline lesz, anélkül, hogy ezt külön odaírnánk. (Ez nem baj, az inline-nak csak előnye van, hátránya nincs.) Használat: // abs double i1=abs(b1); double j1=b1.abs(); cout << "i1=" << i1 << endl; cout << "j1=" << j1 << endl; Mindkét megoldás jó, kinek melyik szimpatikus, azt használja. A tagfüggvényt ugyanúgy objektumnév.tagfüggvény() módon érhetjük el, mint a tagváltozókat Házi feladat a) Készítsen +, -, / operátort az osztályhoz! b) Készítsen arg() globális és tagfüggvényt, mely a komplex vektor szögét adja vissza! 6.2. Osztály class-ból Osztály Készítsünk komplex számok tárolására alkalmas osztályt! class complex_2{ double im,re; ; Ez eddig ugyanúgy néz ki, mint az előbb, de próbáljuk csak beírni, hogy complex_2 a; a.re=3.3;! A fordító hibaüzenettel fog válaszolni, nem érhetjük el a re tagváltozót! class complex_1{ public: double im,re; ; Ha így módosítjuk, akkor az osztályunk és változóink éppen úgy viselkednek, mint a 6.1. pontban. Akár át is írhatjuk az ott közölt programot erre. 27