Programozás alapjai II. (4. ea) C++

Hasonló dokumentumok
Programozás alapjai II. (4. ea) C++

Programozás alapjai II. (4. ea) C++

Programozás alapjai II. (3. ea) C++

Programozás alapjai II. (3. ea) C++ Panaszok kezelése. Hol tartunk?

Programozás alapjai II. (3. ea) C++

Programozás alapjai II. (4. ea) C++ Konstr: létrehoz+inic. (ism.) Inicializáló lista. Konstans tagfüggvények. Destruktor: megszüntet (ism.

Pénzügyi algoritmusok

Programozás alapjai II. (3. ea) C++ Programfejlesztés. Néhány programozási módszer. Feladatanalízis. Modellezés Tervezés. Implementáció (programozás)

Programfejlesztés. Programozás alapjai II. (3. ea) C++ Néhány programozási módszer. Korai szoftverkészítés jellemzői. Gépi nyelv? Strukturált tervezés

Programozás II. 4. Dr. Iványi Péter

Objektumok inicializálása

Programozás alapjai II. (2. ea) C++

Programozás alapjai II. (2. ea) C++ Programfejlesztés. Néhány programozási módszer. Feladatanalízis. Modellezés Tervezés. Implementáció (programozás)

Programozás II gyakorlat. 8. Operátor túlterhelés

Programozás alapjai II. (3. ea) C++

Programozás alapjai II. (2. ea) C++ Programfejlesztés. Néhány programozási módszer. Feladatanalízis. Modellezés Tervezés. Implementáció (programozás)

1. Template (sablon) 1.1. Függvénysablon Függvénysablon példányosítás Osztálysablon

Programfejlesztés. Programozás alapjai II. (3. ea) C++ Néhány programozási módszer. Korai szoftverkészítés jellemzői. Gépi nyelv? Strukturált tervezés

3. Osztályok II. Programozás II

Pénzügyi algoritmusok

Programozás alapjai II. (9. ea) C++ többszörös öröklés, cast, perzisztencia

C++ programozási nyelv Konstruktorok-destruktorok

Bevezetés a programozásba II. 5. Előadás: Másoló konstruktor, túlterhelés, operátorok

Programozás módszertan

Kivételkezelés a C++ nyelvben Bevezetés

Statikus adattagok. Statikus adattag inicializálása. Speciális adattagok és tagfüggvények. Általános Informatikai Tanszék

STL gyakorlat C++ Izsó Tamás május 9. Izsó Tamás STL gyakorlat/ 1

Programozás II. 3. gyakorlat Objektum Orientáltság C++-ban

Bevezetés a programozásba Előadás: Tagfüggvények, osztály, objektum

- 1 - Konstansok használata. Döntsük el, van-e fordítási idejű hiba az alábbi programrészletekben! a) const char * str="zh"; str[0]++;

Programozás C++ -ban 2007/7

Visual C++ osztály készítése, adattagok, és metódusok, láthatóság, konstruktor, destruktor. Objektum létrehozása, használata, öröklés.

OOP #14 (referencia-elv)

Programozás alapjai II. (1. ea) C++

Programozás alapjai II. (1. ea) C++

Programozás. Osztályok, Származtatott osztályok. Fodor Attila

Felhasználó által definiált adattípus

JAVA PROGRAMOZÁS 2.ELŐADÁS

500. CC Megoldó Alfréd CC 500.

Bevezetés a programozásba Előadás: Objektumszintű és osztályszintű elemek, hibakezelés

C++ programozási nyelv

Java II. I A Java programozási nyelv alapelemei

1. Bevezetés A C++ nem objektumorientált újdonságai 3

AA MEGOLDÓ ALADÁR AA

Programozás C++ -ban

Alkalmazott modul: Programozás 8. előadás. Strukturált programozás: dinamikus memóriakezelés. Dinamikus memóriakezelés. Dinamikus memóriakezelés

Java II. I A Java programozási nyelv alapelemei

Bevezetés a programozásba Előadás: A const

A C programozási nyelv V. Struktúra Dinamikus memóriakezelés

Kivételek, kivételkezelés a C++ nyelvben

Programozás alapjai II. (1. ea) C++

Osztályok. 4. gyakorlat

Alkalmazott modul: Programozás 10. fejezet. Strukturált programozás: dinamikus memóriakezelés. Giachetta Roberto

Bevezetés a Programozásba II 2. előadás. Adattípusok megvalósítása egységbe zárással. Adattípusok megvalósítása egységbe zárással

117. AA Megoldó Alfréd AA 117.

500. AA Megoldó Alfréd AA 500.

Globális operátor overloading

Függvények. Programozás alapjai C nyelv 7. gyakorlat. LNKO függvény. Függvények(2) LNKO függvény (2) LNKO függvény (3)

Programozás alapjai C nyelv 7. gyakorlat. Függvények. Függvények(2)

Bevezetés a C++ programozási nyelvbe

Informatika terméktervezőknek

A feladat lényege egy felhasználói típusnak a zsák típusnak a megvalósítása.

C programozási nyelv Pointerek, tömbök, pointer aritmetika

Bánsághi Anna 2014 Bánsághi Anna 1 of 33

1. Alapok. Programozás II

Osztály és objektum fogalma

C# osztálydeníció. Krizsán Zoltán 1. .net C# technológiák tananyag objektum orientált programozás tananyag

Programozás alapjai. 10. előadás

0.2.1 Operátorok túlterhelése (műveletek definiálhatók felhaszn. típusokra) Kutya. Eb1. Eb2. Név (txt): Rex. Blöki. Német juhász 3

Mit ír ki? feladatok megoldásokkal

Programozás I. 3. gyakorlat. Szegedi Tudományegyetem Természettudományi és Informatikai Kar

128. AA Megoldó Alfréd AA 128.

Alprogramok, paraméterátadás

Pelda öröklődésre: import java.io.*; import java.text.*; import java.util.*; import extra.*;

Programozás alapjai II. (1. ea) C++

Java és web programozás

Java és web programozás

Programozás alapjai II. (2. ea) C++

Programozás alapjai II. (2. ea) C++

Programozás C++ -ban

C++ Gyakorlat jegyzet 5. óra. A C++ szabvány több memóriatípust különít el. Ezek közül elsősorban a stack-et használtuk eddig.

Programozás II. 2. Dr. Iványi Péter

és az instanceof operátor

Java V. Osztályszint. lyszintű ű tagok. Példányváltozó. Osztályváltozó. Általános Informatikai Tanszék Utolsó módosítás:

A C++ szigorúbban kezeli a típuseltéréseket, mint a C nyelv Lehetséges típuskonverziók:

Java VIII. Az interfacei. és az instanceof operátor. Az interfészről általában. Interfészek JAVA-ban. Krizsán Zoltán

5. Gyakorlat. struct diak {

Programozás C és C++ -ban

Pénzügyi algoritmusok

.AA Megoldó Alfréd AA.

Bevezetés a Programozásba II 11. előadás. Adatszerkezetek megvalósítása. Adatszerkezetek megvalósítása Adatszerkezetek

8. gyakorlat Pointerek, dinamikus memóriakezelés

Az alábbi példában a Foo f(5); konstruktor hívása után mennyi lesz f.b értéke? struct Foo { int a, b; Foo(int c):a(c*2),b(c*3) {} };

Bevezetés, a C++ osztályok. Pere László

Programozás II gyakorlat. 6. Polimorfizmus

0. Megoldó Manó 0. Programozás alapjai 2. (inf.) pót zárthelyi gyak. hiányzás: 2 n/kzhp: n/11,5. ABCDEF IB.028/2.

228. AA Default Konstruktor AA 228.

1. Mi a fejállományok szerepe C és C++ nyelvben és hogyan használjuk őket? 2. Milyen alapvető változókat használhatunk a C és C++ nyelvben?

A C programozási nyelv I. Bevezetés

Programozási nyelvek Java

Átírás:

Programozás alapjai II. (4. ea) C++ konstruktor és értékadás, dinamikus szerkezetek Szeberényi Imre, Somogyi Péter BME IIT <szebi@iit.bme.hu> M Ű E G Y E T E M 1 7 8 2 C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 1 -

Hol tartunk? C C++ javítások OO paradigmák, objektum fogalma A C++ csupán eszköz: objektum megvalósítása osztály (egységbe zár, és elszigetel), konstruktor, destruktor, tagfüggvények alapértelmezett operátorok, és tagfüggvények operátorok túlterhelése (függvény túlterhelés) Elegendő eszköz van már a kezünkben? C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 2 -

Konstr: létrehoz+alapáll. (ism.) A programozott törzs lefutása előtt számos feladata van. Pl.: létrehozza az class Komplex { adattagokat: hívja azok konstruktorát. double re, im; public: Komplex() { re = 0; im = 0; Komplex(double r) { re = r; im = 0; Komplex(double r, double i) { re = r; im = i; double abs() { return sqrt(re*re+im*im);... ; Komplex k; // paraméter nélkül hívható (default) Komplex k1(1); // 1 paraméteres Komplex k2(1, 1); // 2 paraméteres C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 3 -

Inicializáló lista class Valami { const double c1 = 3.14; // inicializálni kell, de hogyan? Komplex k1; public: Inicializáló lista Valami(double c) { c1 = c; Valami(double c) :c1(c) { Valami(double c, Komplex k) :c1(c), k1(k) { ; Később pontosítjuk Konstans tag, és referencia tag, csak inicializáló listával inicializálható. Célszerű a tagváltozókat is inicializáló listával inicializálni (felesleges műveletek elkerülése). C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 4 -

Destruktor: megszüntet (ism.) class String { unsigned int len; // tároljuk a hosszt char *pdata; // pointer az adatara public: String(int l) { pdata = new int[len = l]; // terület lefoglalása. ~String() { delete[] pdata; // terület felszabadítása ; A programozott törzs lefutása után feladata van. Pl.: megszünteti az adattagokat: hívja azok destruktorát A pdata és a len megszüntetése automatikus, ahogy egy lokális változó is megszűnik. A new-val foglalt dinamikus terület felszabadítása azonban a mi feladatunk, ahogyan C-ben is fel kell szabadítani a dinamikusan foglalt területet. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 5 -

Műveletekkel bővített Komplex (ism.) class Komplex { double re, im; public:... Komplex operator+(const Komplex& k) { Komplex sum(k.re + re, k.im + im); return(sum); Komplex operator+(const double r) { return(operator+(komplex(r))); ;... Komplex k1, k2, k3; k1 + k2; k1 + 3.14; k1 = k2; 3.14 + k1; // bal oldal nem osztály! // Ezért globális függvény kell! Alapértelmezett C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 6 -

double + Komplex (ism.) class Komplex {... ; Globális fv., nem tagfüggvény: Komplex operator+(const double r, const Komplex& k) { return(komplex(k.re + r, k.im)); Baj van! Nem férünk hozzá, mivel privát adat! 1. megoldás: privát adat elérése pub. fv. használatával: Komplex operator+(const double r, const Komplex& k) { return(komplex(k.getre() + r, k.getim())); Publikus lekérdező függvény C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 7 -

2. megoldás: védelem enyhítése Szükséges lehet a privát adatok elérése egy globális, függvényből, vagy egy másik osztály tagfüggvényéből. Az ún. barát függvények hozzáférhetnek az osztály privát adataihoz. Rontja az átláthatóságot és gyengíti az egységbezárás elvét, ezért nem kedveljük. class Komplex {... public: // FONTOS! Ez nem tagfüggvény, csak így jelöli, hogy barát friend Komplex operator+(const double r, const Komplex& k); ; Komplex operator+(const double r, const Komplex& k) { k.re... k.im... // hozzáfér a privát adatohoz C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 8 -

Alapértelmezett tagfüggvények (ism.) Konstruktor default: X() // nincs paramétere másoló: X(const X&) // referencia paraméter Destruktor operator=(const X&) // értékadó operator&() // címképző operator*() // dereferáló operator->() // tag elérése pointerrel operator,(const X&) // vessző A másoló konstruktor és az értékadó operátor alapértelmezés szerint meghívja az adattagok megfelelő tagfüggvényét. Alaptípus esetén (bitenként) másol! C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 9 -

Példa: Intelligens string String tárolására alkalmas objektum, ami csak annyi helyet foglal a memóriában, amennyi feltétlenül szükséges. dinamikus adatszerkezet Műveletei: létrehozás, megszüntetés indexelés: [] másolás: = összehasonlítás: == összefűzés: (String + String), (String + char) (char + String) kiírás: cout << beolvasás: cin >> C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 10 -

String adatszerkezete char *p int len H E L L O \0 dinamikus memória (heap) C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 11 -

String osztály class String { char *p; unsigned int len; public: String(const char *s = "") { p = new char[(len = strlen(s)) + 1]; strcpy(p, s); ~String( ) { delete[] p; ; Ez a default (paraméter nélkül hívható) konstruktor is new[] után csak így! const char& operator[] (int i) const { return p[i]; char& operator[] (int i) { return p[i]; referenciát ad, így balérték is lehet C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 12 -

Függvényhívás mint balérték int main ( ) { String s("hello"); const String cs("konstans"); // konstruktorok: s.p = new char[6] s.len = 5 // cs.p = new char[9] s.len = 8 char c = s[3]; // c = s.operator[](3); c=s.p[3]; c = cs[4]; // c = cs.operator[](4) const; c=cs.p[4]; s[1]= u'; // s.operator[](1) =' u'; s.p[1]='u'; // destruktorok: delete[] cs.p, // delete[] s.p C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 13 -

Értékadás problémája { String s1("baj"); String s2("van!"); s1 char *p baj\0 int len = 3 s2 char *p int len = 4 van!\0 C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 14 -

Értékadás problémája { String s1("baj"); String s2("van!"); s1 char *p baj\0 int len = 3 s2 char *p int len = 3 s2 = s1; van!\0 // destruktor baj -ra 2x, van -ra 0x C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 15 -

class String {... String& operator=(const String& s) { // s1=s2=s3 miatt ; Megoldás: operátor= átdefiniálás if (this!= &s ) { Paraméterként kapja azt, amit értékül kell adni egy létező objektumnak. // s = s kivédésére delete[] p; p = new char[(len = s.len) + 1]; strcpy(p, s.p); return *this; // visszaadja saját magát C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 16 -

operator=-vel már nincs baj { String s1("baj"); String s2("van!"); s1 s2 char *p int len = 3 char *p int len = 43 s2 = s1; baj\0 van!\0 baj\0 // destruktorok rendben C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 17 -

Kezdeti értékadás problémája { String s1("baj"); String s2 = s1; s1 char *p int len = 3 baj\0 s2 char *p int len = 3 // destruktorok baj -ra 2x C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 18 -

Megoldás: másoló konstruktor Referenciaként kapja azt a példányt, amit lemásolva létre kell hoznia egy új objektumot. class String {... String(const String& s) { p = new char[(len = s.len) + 1]; strcpy(p, s.p); C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 19 -

Másoló konstruktorral már jó { String s1("baj"); String s2 = s1; s1 s2 char *p int len = 3 char *p int len = 3 baj\0 baj\0 // destruktorok rendben C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 20 -

Miért más mint az értékadás? A kezdeti értékadáskor még inicializálatlan a változó (nem létezik), ezért nem lehet a másolással azonos módon kezelni. Mikor hívódik a másoló konstruktor? inicializáláskor (azonos típussal inicializálunk) függvény paraméterének átadásakor függvény visszatérési értékének átvételekor ideiglenes változók összetett kifejezésekben kivétel átadásakor C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 21 -

Függvényhívás és visszatérés Hívás String s0, s1; s1 = f (s0); s1 tmp tmp s0 s (verem) tmp r Hívott String f ( String s ) { String r;... return r; r, s C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 22 -

Összetett algebrai kifejezés String s, s0, s1, s2; s = s0 + s1 + s2; 1. lépés: tmp1=s0+s1 2. lépés: 3. lépés: 4. lépés: tmp2=tmp1+s2 s = tmp2 tmp1, tmp2 megszüntetése destruktor hívással C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 23 -

String rejtvény class String { char *p; unsigned int len; public: String( ); // 1 String(char *); // 2 String(const String&); // 3 ~String( ); // 4 String operator+(string&); // 5 char& operator[](int); // 6 String& operator=(string&);// 7 ; int main( ) { String s1("rejtvény"); String s2; String s3 = s2; char c = s3[3]; s2 = s3; s2 = s3 + s2 + s1; return 0; // destr. 2 1 3 6 7 5,3,5,3, (3),7,4,4,(4) 4,4,4 C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 24 -

String rejtvény/2 class String { char *p; unsigned int len; public: String( ); // 1 String(char *); // 2 String(const String&); // 3 ~String( ); // 4 String operator+(string&); // 5 char& operator[](int); // 6 String operator=(string); // 7 ; int main( ) { String s1("rejtvény"); 2 String s2; 1 String s3 = s2; 3 char c = s3[3]; 6 s2 = s3; 3,7,4 s2 = s3 + s2 + s1; 5,3,5,3, (3),3,7,4,4,4,(4) return 0; // destr. 4,4,4 C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 25 -

Miért referencia? Miért kell referencia a másoló konstruktorhoz? A paraméterátadás definíció szerint másoló konstruktort hív. Ha a másoló konstruktor nem referenciát, hanem értéket kapna, akkor végtelen ciklus lenne. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 26 -

Miért fontos a delete[]? String *st = new String[3]; char *p st[0] int len = 0 st[1] char *p int len = 0 st[2] char *p int len = 0 \0 \0 \0 A delete st hatására csak a *st, azaz az st[0] destruktora hívódik meg! Az st[1] és az st[2] által foglalt memória nem szabadul fel! A delete[] meghívja minden elem destruktorát. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 27 -

Védelem enyhítése Nem tagfüggvény! String + class String {... String operator+(const String& s); String operator+(char c); friend String operator+(char c, const String& s); ; String operator+(char c, const String& s) { char *p = new char[s.len + 2]; *p = c; strcpy (p+1, s.p); String ret(p); delete[] p; return ret; C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 28 -

String + friend nélkül class String {... String operator+(const String& s); String operator+(char c); ; String operator+(char c, const String& s) { return String(c) + s; Egyszerűbb és szebb is. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 29 -

Keletkezett-e +=? Az alaptípusokra meghatározott műveletek közötti logikai összefüggések nem érvényesek a származtatott típusokra. Azaz az operator= és az operator+ meglétéből nem következik az operator += Ha szükség van rá, definiálni kell. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 30 -

Változtatható viselkedés Feladat: "Varázsütésre" az összes String csupa nagybetűvel íródjon ki! Megoldás: viselkedést befolyásoló jelző, de hol? objektum állapota (adata) csak az adott példányra van hatása. globális változó elég ronda megoldás! az osztályhoz rendelt állapot: statikus tag ill. tagfüggvény. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 31 -

Statikus tag Az osztályban statikusan deklarált tag nem példányosodik. Pontosan egy példány létezik, amit explicit módon definiálni kell (létre kell hozni). Minden objektum ugyanazt a tagot éri el. Nem szükséges objektummal hivatkozni rá. pl: String::SetUcase(true); Statikus tagként az osztály tartalmazhatja önmagát. Felhasználás: globális változók elrejtése C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 32 -

String statikus taggal class String { char *p; unsigned int len; static bool ucase; // statikus tag deklarálása public:... static void Ucase(bool b) { ucase = b; // beállít static bool Ucase() { return ucase; // lekérdez friend ostream& operator<<(ostream& os, const String& s); ; bool String::ucase = false; // FONTOS!! Adattag definíciója C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 33 -

String statikus taggal /2 ostream& operator<<(ostream& os, const String& s) { for (unsigned int i = 0; i < s.len; i++) { char ch = s.ucase? toupper(s.p[i]) : s.p[i]; os << ch; // miért kell ch? return os; Osztályhoz tartozik, nem a példányhoz. Lehetne String::ucase is C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 34 -

String statikus taggal /3 //Friend nélkül: ostream& operator<<(ostream& os, const String& s) { for (unsigned int i = 0; i < s.size(); i++) { char ch = String::Ucase()? toupper(s[i]) : s[i]; os << ch; return os; Publikus tagfüggvényekkel C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 35 -

Statikus adattag inicializálás Ha a statikus adattag konstans és integrál- vagy enum típusú, akkor inicializálható az osztály deklarációjában is. Ez a definíciót is kiváltja. struct A { ; static const int a = 35; // definíció is static enum { s1, s2 const st = s1; const int A::a = 35; Nem kell/szabad C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 36 -

Adattag inicializálás C++98: Csak konstruktorban Csupán érdekesség (szorgalmi): C++11-től: Az osztály deklarációjában is lehet. Ha mindkettőben van, akkor a deklarációnál megadott nem hajtódik végre. struct B { B(int i = 0) {cout << i; ; struct A { int a = 35; B b0 = B(); // kiír: 0 B b1 = B(); // ez nem hajtódik végre A() :b1(b(1)) {// kiír: 1 ; C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 37 -

Memóriakép (ism.) 0 memória cím text (code) initilalized data uninitilalized data(bss) heap Végrehajtható programfájlból (dikszkről/epromból) induláskor törlődik malloc/new 0xFFFFFF stack lokális változók, fv. paraméterek, visszatérési címek C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 38 -

Data szegmens C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 39 -

Példa cat maci.cc char buf[100]; // 100 byte bss char duma[] = "Hello!"; // 8 byte data const char *pp = "C++"; // 8 byte data + 4 RO data void f() { //?? byte text g++ c maci.cc size -A maci.o section size addr.text 6 0.data 16 0.bss 100 0.rodata.str1.1 4 0.comment 50 0 C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 40 -

Mi van a motorházban? g++ S maci.cc more maci.s.globl buf.bss buf:.zero 100.globl duma.data duma:.string "Hello!".globl pp.section.rodata.lc0:.string "C++".data pp:.quad.lc0.text.type _Z1fv, @function _Z1fv: pushq %rbp movq %rsp, %rbp popq %rbp ret C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 41 -

Komplex példa újból Olvassunk be adott/tetszőleges számú komplex számot és írjuk ki a számokat és abszolút értéküket fordított sorrendben! Objektumok: Komplex, KomplexTar konstruktorban adott a méret: a) változat igény szerint változtatja a méretét: b) változat Mindkét megoldás dinamikus memóriakezelést igényel. Ügyelni kell a helyes felszabadításra, foglalásra. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 42 -

KomplexTar osztály class KomplexTar { Komplex *t; // pointer a dinamikusan foglalt tömbre int db; // elemek száma/ tömb mérete public: class Tar_Hiba {; // osztály az osztályban a hibakezeléshez KomplexTar(int m = 10) :db(m) { t = new Komplex[m]; // konstruktor (def = 10) KomplexTar(const KomplexTar& kt);// másoló konstruktor Komplex& operator[](unsigned int i);// indexelés Komplex operator[](unsigned int i) const ;// indexelés KomplexTar& operator=(const KomplexTar& kt); // értékadás ~KomplexTar() { delete[] t; // felszabadítás ; C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 43 -

KomplexTar osztály/2 KomplexTar::KomplexTar(const KomplexTar& kt){//másoló konstr. t = new Komplex[db = kt.db]; for (int i = 0; i < db; i++) t[i] = kt.t[i]; // miért nem memcpy? A memcpy nem hívná meg a konstruktort KomplexTar& KomplexTar::operator=(const KomplexTar& kt) {// = if (this!= &kt) { delete[] t; t = new Komplex[db = kt.db]; for (int i = 0; i < db; i++) t[i] = kt.t[i]; // miért nem memcpy? return *this; Visszavezettük értékadásra KomplexTar::KomplexTar(const KomplexTar& kt){//másoló 2.vált. t = NULL; *this = kt; // trükkös, de rendben van! C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 44 -

a) Indexelés és a főprogram Komplex& KomplexTar::operator[](unsigned int i) { if (i >= db) throw Tar_Hiba(); return t[i]; int main() { KomplexTar t(5); // a tárolóban 5 elemünk van try { for (int i = 0; i < 20; i++) cin >> t[i]; // beolvasás KomplexTar t2 = t1; // másoló konstruktor for (i = 19; i >= 0; i--) cout << t[i] ' ' << (double)t[i] << endl; // kiírás catch (KomplexTar::Tar_hiba) { cerr << "Indexelesi hiba\n"; // hibakezelés return(0); C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 45 -

b) Változó méretű KomplexTar // Indexelés hatására növekszik a méret, ha kell Komplex& KomplexTar::operator[](unsigned int i) { if (i >= db) { // növekednie kell, célszerű kvantumokban Komplex *tmp = new Komplex[i+10]; // legyen nagyobb for (int j = 0; j < db; j++) tmp[j] = t[j]; // átmásol delete[] t; // régi törlése t = tmp; // pointer az új területre db = i + 10; // megnövelt méret return t[i]; // referencia vissza // Konstans tároló nem tud növekedni Komplex KomplexTar::operator[](unsigned int i) const { if (i >= db) throw Tar_Hiba(); return t[i]; C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 46 -

c) Gyakorlatiasabb változat class KomplexTar { static const unsigned int nov = 3; // növekmény érteke Komplex *t; // pointer a dinamikusan foglalt adatra unsigned int db; // elemek száma unsigned int kap; // tömb kapacitása public: KomplexTar(int m = 10) :db(m), kap(m+nov) { t = new Komplex[kap]; KomplexTar(const KomplexTar&); unsigned int capacity() const { return kap; unsigned int size() const { return db; Komplex& operator[](unsigned int i); Komplex operator[](unsigned int i) const ; // lehetne const Komplex& is KomplexTar& operator=(const KomplexTar&);... C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 47 -

c) Gyakorlatban használhatóbb Komplex& KomplexTar::operator[](unisgned int i) { if (i >= kap) { Komplex *tmp = new Komplex[i+nov]; // legyen nagyobb for (unsigned int j = 0; j < db; j++) tmp[j] = t[j]; // átmásol delete[] t; // régi törlése t = tmp; // pointer az új területre kap = i + nov; // megnövelt kapacitás if (i >= db) db = i+1; // megnövelt darab return t[i]; // referencia vissza Komplex KomplexTar::operator[](unsigned int i) const { if (i >= db) throw Tar_Hiba(); return t[i]; http://svn.iit.bme.hu/proga2/eloadas_peldak/ea_04/ C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 48 -

Összefoglalás /1 INICIALIZÁLÁS!= ÉRTÉKADÁS Inicializáló lista szerepe. Alapértelmezett tagfüggvények. Dinamikus szerkezeteknél nagyon fontos a másoló konstruktor és az értékadás felüldefiniálása. (nem maradhat alapért.) Default konstruktornak fontos szerepe van a tömböknél. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 49 -

Összefoglalás /2 Konstans tagfüggvények nem változtatják az objektum állapotát. Statikus tag és tagfüggvény az osztályhoz tartozik. Védelem enyhítése: friend Létrehozás, megsemmisítés feladatait a konstruktor és destruktor látja el. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 50 -

Létrehozás, megsemmisítés Konstruktor default: X() // nincs paramétere automatikusan létrejön, ha nincs másik konstr. másoló: X(const X&) // referencia paramétere van, automatikusan létrejön: meghívja az adattagok másoló konstr.-át, ha objektumok, egyébként bitenként másol. Destruktor delete[ ] // [ ] nélkül csak a 0. tömbelemre!! automatikusan létrejön: meghívja az adattagok destr. operator=(const X&) // értékadó operátor automatikusan létrejön: meghívja az adattagok értékadó operátorát, ha objektumok, egyébként bitenként másol. C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 51 -

Milyen furcsa kommentek! A kommentekből automatikusan generál dokumentációt a Doxygen program. (html, latex, rtf, man,... formátumban) Csak jó kommentből lesz jó dokumentáció! /** Speciális kezdet Rövid leírás ponttal zárva * Komplex osztály. * Komplex viselkedést megvalósító osztály. * Csak a feladat megoldásához szükséges műveleteket definiáltuk. Részletesebb leírás */ class Komplex { C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 52 -

Milyen furcsa kommentek! /2 Speciális kezdet /** Rövid leírás ponttal zárva * Komplex osztály. * Komplex viselkedést megvalósító osztály. * Csak a feladat megoldásához szükséges műveleteket definiáltuk. */ class Komplex { Részletesebb leírás C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 53 -

Milyen furcsa kommentek! /3 class Komplex {... /** * Konstruktor nulla, egy és két paraméterrel * @param r - valós rész (alapértelmezése 0) * @param i - képzetes rész (alapértelmezése 0) */ Komplex(double r = 0, double i = 0) :re(r), im(i) { Paraméterek dokumentálása Speciális kezdet Rövid leírás operator double() { return sqrt(re*re + im*im); ///< abszolút érték friend istream& operator>>(istream& s, Komplex& k) ; ///< Komplex beolvasás friend ostream& operator<<(ostream& s, const Komplex k); ///< Komplex kiírás C++ programozási nyelv BME-IIT Sz.I. 2018.02.27. - 54 -