String osztály létrehozása

Az előadások a következő témára: "String osztály létrehozása"— Előadás másolata:

1 String osztály létrehozása

2 Sztring osztály létrehozása
Feladat: Készítsünk olyan programot, amely sztringeket képes létrehozni, valamint azokkal műveleteket végezni. Az igényelt műveletek: sztring egyes karaktereinek írása illetve olvasása, sztringek másolása, összefűzése, összehasonlítása és nyomtatása.˙

3 Objektumokat leíró táblázat:

4 Műveletek: tipikusan operátorokkal célszerű reprezentálni őket.
Attribútumok: a specifikáció nem ad támpontot. Régebbi tapasztalatainkra támaszkodjunk! Figyelembe veendő szempontok: tárolt karakterek száma előre nem ismert és az objektum élete során is változó. Kézenfekvő a karakterek helyét a dinamikus memóriából lefoglalni, az attribútumok között csak az adminisztrációhoz szükséges változókat tartjuk nyilván. Ilyen változó: karaktersorozat kezdőcíme a heap-en (pstring) a sztring aktuális hossza (size).

5 size: redundáns adat, hiszen számolható
size: redundáns adat, hiszen számolható Fennáll az inkonzisztencia veszélye. Hatékonyság miatt azonban célszerű!

6 Sztring osztály definíciója
class String { char *pstring; int size; public: String (char* s = ““) { //String default konstruktor pstring = new char [ size = strlen (s) + 1 ]; strcpy(pstring,s); } ~String ( ) { delete [ ] pstring ; } char& operator [ ] (int i ) { return pstring [ i ]; } String operator+( String& s ) { char *psum = new char [size + s.size - 1 ]; strcpy (psum, pstring ); strcat (psum, s.pstring) ; String sum (psum ); delete psum; return sum; } };

7 A konstruktor feladata
- az átadott sztring alapján a szükséges terület lefoglalása a heap-en - a sztring heap-re másolása - az adminisztrációs adattagok kitöltése A konstruktordefiníció tartalmazza az alapértelmezésű (paramétert nem igénylő konstruktort is ( alapértelmezésű argumentuma miatt)

8 Destruktor feladata A heap-en lefoglalt terület felszabadítása.

9 Az index operátor Feladata: használatával egy karaktert lekérdezhetünk, illetve megváltoztathatunk. Fontos! Referencia típus· a visszatérési értéke.

10 main() {. char c;. String s (“én string vagyok” );. c = s [ 3 ];
main() { char c; String s (“én string vagyok” ); c = s [ 3 ]; // c=s.operator[] (3); c=pstring[3]; s[ 2 ] = ‘a’; // s.operator[] (2)=‘a’; pstring[2]=‘a’; } //delete [] pstring

11 Az index operátor c= s[ 3 ]; az operátor átdefiniálás szerint ekvivalens a c=s.operator[](3) utasítással, ami viszont a String::operator[] törzse szerint a c-hez a string[3]-t rendeli hozzá. s[2] = ‘a’ viszont a s.operator [](2) = ‘a’-nak felel meg. Ez az értékadás bal oldalán függvényhívást jelent. C-ben nem megengedett. Nem referencia típusú visszatérési érték esetén visszaadná a sztring 2-ik karakterének értékét. Referencia típus miatt az s.operator [](2) a pstring[2] helyettesítő neve, így értéke meg is változtatható

12 Referencia típus Amennyiben olyan függvényt írunk, amelyet balértékként (az értékadás bal oldalán) akarunk használni, akkor annak referenciát kell visszaadnia. Az index operátor szinte mindig referencia típusú!

13 Összeadás operátor - Ideiglenesen foglalunk egy karaktertömböt - előállítjuk az összefűzött sztringet (az -ideiglenesen foglalt tömbben) - megkonstruáljuk a visszatérési érték String típusú objektumát. - az ideiglenes tömböt felszabadítjuk - visszatérünk és visszatérési értékünk a létrehozott objektum.

14 Problémák : értékadásnál
Tekintsük a következő programrészletet: { String s1 (“baj”), s2 ("van!"); s2 = s1; } Az értékadás operátor (=) az adattagokat egy az egyben másolja (bitmásolás)

15 Bitmásolás most nem jó! s2.size is 4 értékű lesz
“baj”-ra két mutató is mutat, míg “van”-ra egy sem. ha s1 változik, akkor s2 is változik a “baj” kezdőcímére két delete-t hajt végre a program a destruktor meghívásakor, míg a “van”-t senki sem szabadítja fel.˙

16 Értékadó operátor átdefiniálása
class String { void operator=(String& ); }; void String :: operator=(String& s) { delete pstring; pstring = new char [size = s.size]; strcpy (pstring, s.pstring); }

17 További problémák //nem lehet s1=s2=s3;
s1=s2=s3 nem megengedett Ez ekvivalens lenne a következővel: s1.operator=(s2.operator=(s3)); s1.operator= bemenő argumentuma az s2.operator=(s3) visszatérési értéke, ami viszont void, holott String& kellene, hogy legyen. Megoldás: visszatérési érték megváltoztatása 

18 Még további probléma s=s; értékadás hibásan működik. Ekkor ugyanis az s.operator= referenciaként megkapja s-t, azaz önmagát, amelyhez tartozó heap területet felszabadítja, majd innen másol.  Megoldás lehet, hogy megvizsgáljuk, hogy a referenciaként átadott objektum címe megegyezik-e a célobjektum címével.

19 Javított változat class String { String& operator=(String& ); //s1=s2=s3; lehet }; String& String :: operator=(String& s) { if (this != &s ) { //s = s ; miatt delete pstring; pstring = new char [size = s.size]; strcpy (pstring, spstring); } return *this; }

20 Problémák 2. Értékadással kapcsolatos problémák megoldódtak. Kivéve: ha =-et használunk valamely objektumpéldány kezdőértékkel való ellátására.: { String s1(“baj”); String s2 = s1; }

21 Az itt szereplő = jel nem az értékadás, hanem az inicializálás műveletét jelöli.
Inicializálás alapértelmezése: bitenkénti másolás. (Ha nem lenne különbég a kettő között és az operator= mindkét esetben felülbírálja a műveletet, akkor a String s2 = s1 utasításból kialakuló s2.operator=(s1) függvényhívás azzal indulna, hogy a delete s2.pstring utasítást hajtaná végre (Pedig a pstring még nincs is inicializálva! Az operator= fv-ben nem tudjuk eldönteni, hogy volt-e már inicializálva egy objektum, vagy sem).

22 Problémák 2. Beláttuk, - hogy jó, ha nem hívja meg az operator= függvényt - rossz, hogy az inicializálás alapértelmezése szerinti műveletet hajtja végre (bitmásolás) Megoldás “inicializáló operátort” az ún. másoló konstruktort kell átdefiniálni.

23 Másoló konstruktor Másoló konstruktor - az osztály nevét kapja - a másoló jellegét az adja, hogy ugyanolyan típusú objektummal kívánjuk inicializálni, ezért az argumentuma is ezen osztály referenciája - egy x osztályra a másoló konstruktor x ( &x).

24 Másoló konstruktor A String osztály kiterjesztése másoló konstruktorral: class String { String ( String& s ); }; String::String ( String& s ) { pstring = new char [size = s.size ]; strcpy ( pstring, s.pstring); }

25 Másoló konstruktor Definícióban történő inicializálás (az előbb láttuk a példát) Függvény argumentum és visszatérési érték Érték szerinti paraméterátadás esetén az argumentumok a verem memóriába kerülnek. A verem memórián tartózkodó ideiglenes változóba másolás megfelel az inicializálatlan objektum kitöltésének. A verembe másolást a másoló konstruktor végzi el.

26 s0 vermen lévő másolatát s-et a másoló konstruktor inicializálja.
Hívás Hívott String s0, s1; s1 = f (s0); String f ( String s ) { String r; //(stack) temp temp return r; } // r, s

27 Visszatérési érték kezelése
- skalár érték esetén regisztert használnak - objektumok azonban nagyobb méretűek, így gyakran a globális memóriát, a heap-et vagy a veremmemóriában lefoglalt területet kell igénybe venni. A visszatérési értéket átadó memóriaterület azonban inicializálatlan, tehát a return utasítás is csak a másoló konstruktor hívásával másolhatja be a visszatérési értéket.

28 Tanulságok A létrehozott String osztály tulajdonságai: - dinamikusan nyújtózkodó szerkezet, amely minden pillanatban csak annyit foglal el a memóriából, amennyit feltétlenül szükséges. - String típusú objektumok tetszőleges számban előállíthatók. Olyan egyszerűen használhatók, mint a beépített típusok.

29 Öröklés Az örököltetés szintaktikája:
class származtatott osztály_név: elérési mód bázis-osztály_név { // … }

30 Elérési módok a származtatásnál
public private protected

31 A származtatás: public
//Alaposztály class base { int x; public: void setx (int n ) { x=n; } void showx() { cout <<x << ‘\n’; } };

32 Származtatott osztály
class derived : public base { int y; public: void sety (int n ) { y=n; } void showy() { cout <<y << ‘\n’; } };

33 Publikus tagok elérése
main() { derived ob; ob.setx (10); //eléri az alaposztály tagjait ob.sety (20); //eléri a származtatott osztály tagjait ob.showx (); //eléri az alaposztály tagjait ob.showy (); //eléri a származtatott osztály tagjait return 0; }

34 A private tagok nem elérhetők
//Alaposztály class base { int x; public: void setx (int n ) { x=n; } void showx() { cout <<x << ‘\n’; } };

35 private tagra nem hivatkozhatunk!
class derived : public base { int y; public: void sety (int n ) { y=n; } void show_sum() { cout <<x+y << ‘\n’; } //hiba! //x private tag void showy() { cout <<y << ‘\n’; } };

36 A származtatás: private
//Alaposztály class base { int x; public: void setx (int n ) { x=n; } void showx() { cout <<x << ‘\n’; } };

37 Származtatott osztály
class derived : private base { int y; public: void sety (int n ) { y=n; } void showy() { cout <<y << ‘\n’; } };

38 Publikus tagok elérése
main() { derived ob; ob.setx (10); //hiba, ez privát a származtatott osztályban ob.sety (20); //eléri a származtatott osztály tagjait ob.showx (); //hiba, ez privát a származtatott osztályban ob.showy (); //eléri a származtatott osztály tagjait return 0; }

39 Megoldás az előző példára A származtatás: private
//Alaposztály class base { int x; public: void setx (int n ) { x=n; } void showx() { cout <<x << ‘\n’; } };

40 Származtatott osztály
class derived : private base { int y; public: void setxy (int n, int m ) {setx(n); y=m; } void showxy() {showx(); cout <<y << ‘\n’; } };

41 Publikus tagok elérése
main() { derived ob; ob.setxy(10,20); //eléri a származtatott osztály tagjait ob.showxy (); //eléri a származtatott osztály tagjait return 0; }

42 protected tagok elérése
//Alaposztály class samp { int a; protected: int b; public: int c; samp(int n, int m) { a=n; b=m;} int geta ( ) { return a; } int getb ( ) {return b;} };

43 Hozzáférés protected tagokhoz
main() { //ob.b=99; //hiba!!! ob.c=30; //OK. cout<< ob.geta() << ‘ ‘; cout<< ob.getb() << ‘ ‘<<ob.c<<‘\n’; return 0; }

44 protected tagok //Alaposztály class base { protected: int a,b; public:
void setab(int n, int m) { a=n; b=m;} };

45 Származtatott osztály
class derived : public base { public: void setc (int n) { c=n;} void showabc() { cout<<a<<‘ ‘ <<b<< ‘ ‘ <<c << ‘\n’; } };

46 Publikus tagok elérése
main() { derived ob; ob.setab(1,2); ob.setc (); Ob.showabc(); return 0; }

47 Konstruktorok, destruktorok és a származtatás
A bázis osztály és a származtatott osztályok is rendelkezhetnek konstruktorokkal és destruktorokkal. A konstuktorok végrahajtásának sorrendje a származtatásnak megfelelő sorrendben történik. A destruktorok végrehajtása a származtatás sorrendjével ellenkező sorrendben történik.

48 Konstruktorok paraméterei
Különböző esetek: Alaposztálynak és származtatott osztálynak nincs paramétere Alaposztálynak nincs paramétere Származtatott osztálynak nincs, de a bázis osztálynak van paramétere Bázis osztálynak is és a származtatott osztálynak is van paramétere.

49 Bázis és származtatott osztály konstruktorainak végrehajtási sorrendje
#include <stdio.h> class base { public: base { cout << „Bázis osztály konstruktora\n”;} ~base { cout << „Bázis osztály destruktora\n”;} }; Class derived: public base { public; derived { cout << „Származtatott osztály konstruktora\n”;n ~derived { cout << „Származtatott osztály destruktora\n”;}

50 A konstruktorok és destruktorok lefutása
main () { derived o; return 0; } Output: Bázis osztály konstruktora Származtatott osztály konstruktora Származtatott osztály destruktora Bázis osztály destruktora

51 Paraméterek átadása #include <stdio.h> class base { int i;
public: base ( int n) { cout << „Bázis osztály konstruktora\n”; i=n;} ~base { cout << „Bázis osztály destruktora\n”;} void show() { cout <<i << ‘\n’; } };

52 class derived: public base {
int j; public; derived ( int n, int m) : base(m) { cout << „Származtatott osztály konstruktora\n”; j=n; } ~derived { cout << „Származtatott osztály destruktora\n”;} void showj () { cout<< j << ‘\n’;} };

53 main() { derived o(10,20); o.showi(); o.showj(); return 0; }