Please enable JavaScript.

Coggle requires JavaScript to display documents.

C++ - Coggle Diagram

- - - - ...ellenőrizni kell azt az esetet, ha magának adna értéket
      - ...a már lefoglalt memóriáját fel kell szabadítani
  - - - Több shared_ptr is rendelkezhet ugyanazon objektummal (száma lekérdezhető a use_count() függvénnyel)
    - - Ugyanazon objektummal csak egy unique_ptr rendelkezhet
      - Ha értéknek akarjuk adni, használnunk kell a move() függvényt, de ha referenciaként várja a függvény, akkor csak átadjuk
- - - - Használható a [] operátor is, de nem biztonságos - előzetes ellenőrzés erősen ajánlott
      - A size_t at(size_t pos) tagfüggvény out_of_range kivételt dob rossz index esetén
      - A kereséshez használt...
        
        find()
        
        find_first_of()
        
        find_first_not_of()
        
        find_last_of()
        
        find_last_not_of()
        
        ...tagfüggvények pozíciót vagy string::npos-t adhatnak vissza.
    - - std névtér tagjai, nem a string osztálynak
      - Stringgé konvertálás: to_string()
      - Számmá konvertálás: stoi, stol, stof, stod, stoul, stoull, stoll, stold
  - - - Állapot
      - Viselkedés
      - Identitás
    - - Nem része az osztálynak
      - Osztályban lehet egy másik osztályt, külső- és tagfüggvényt megjelölni
      - Láthatóvá teszi a private és protected tagokat
      - Nem kölcsönös
    - - Aktuális objektumra mutató pointer
        
        ezért írunk return *this-t, ha értéket vagy referenciát adunk vissza
      - Automatikusan beállítódik
    - - Nem változtatható meg...
        
        ...prioritás
        
        ...asszociációt
        
        ...paramétereinek számát
      - Ha egy másik példány adattagját akarunk használni:
        
        lehet globális operátor
        
        vagy friend függvény:
        class MyClass { int a; public: friend MyClass operator+(const MyClass& other) { return { a + other.a } } };
      - Konverziós
        
        Visszatérési típust nem kell megadni
        
        Lehet const is
        
        Mellékhatások és többértelmű hívás elkerülése végett érdemes explicitté tenni, ekkor használatkor ki kell írni a típust, hogy mire akarunk konvertálni
    - - Példányosításkor automatikusan lefut
      - Név == osztály neve
      - Nem lehet...
        
        ...közvetlenül hívni
        
        ...const vagy static
        
        ...visszatérési típusa
        
        ...leszármaztatni
      - Inicializáló lista
        
        Delegálás
        
        Csak inicializáló listából hívható
        
        Ugyanazon osztály egy másik konstruktorának használata egy konstruktor által
        
        Ha meghívunk egy másik konstruktort, nem inicializálhatunk adattagokat az aktuálisban
        
        class MyClass { int x, y; public: MyClass() : MyClass(42), y(10) {} // HIBÁS, de az y(10) nélkül jó lenne MyClass(int v) : x(v), y(v + 1) {} };
        
        Mivel a referencia adattagokat kötelező inicializálni már a konstruktor törzsébe való belépés előtt, így ez itt oldható meg.
      - Lehet láthatósága
      - Ha nincs, akkor a fordító generál egy paraméter nélküli default konstruktort
      - Az adattagok a definiálás sorrendjében inicializálódnak
        
        class MyClass { int y, x; public: MyClass() : y(10), x(y) {} }; // ezesetben az x inicializálatlan // így a cout memóriaszemetet ír ki
    - - ha törölve van a konstruktora...
        class MyClass { public MyClass() = delete; };
      - publikus konstruktor hiánya esetén osztályon kívülről
        (singleton osztálynál használatos)
      - absztrakt osztály esetén
    - - Adattag
        
        Nem módosítható
      - Tagfüggvény
        
        Nem összekeverendő a konstanst visszaadó függvénnyel
        class MyClass { const int getA() {} // << nem ez az int getB() const {} // << ő itt most a lényeg };
        
        Nem...
        
        ...változtathatja meg az objektum állapotát
        
        ...hívhat meg nem const metódust a saját osztályából (!)
        
        ...adhat vissza nem const referenciát az adattagra
        
        ...igaz fordítva, azaz nem const függvény hívhat const-ot
        
        Működik konstans és nem konstans példányon, de nem const függvény nem hívható konstans példányon
        
        Egy adott foo() függvény létezhet const és nem const változatként, illetve több paraméterlistával is
        class MyClass { void foo(); void foo(int x); void foo(int x, int y); void foo(int x, int y) const; // ez is megengedett };
      - Ha mutable-nek jelölünk egy adattagot, const metódus esetén is módosítható
    - - Objektum megszűnésekor automatikusan hívódik
      - Nem lehet paramétere
      - Osztályonként egy lehet
      - Nem lehet visszatérési értéke
      - A nyers pointerek itt kell gondoskodni a felszabadításáról
      - Ha leszármaztatjuk az osztályt, érdemes virtuálissá tenni
      - Létrehozással ellentétes sorrendben szűnnek meg az objektumok
    - - Verem: függvények/metódusok lokális változói
      - Kupac: dinamikusan foglalt objektumok
      - Statikus: metódusban, osztályban
      - Globális: nem része osztálynak vagy függvénynek, névtér része lehet
  - - - private (alap)
        
        private és protected tagok private-k lesznek
      - protected
        
        public tagok protected-ek lesznek
      - public
        
        minden marad ugyanolyan láthatóságú
      - Minden esetben a szülőosztály tagok részei lesznek a gyerekosztálynak, mégha nem is érhetőek el
    - - Leszármazott osztály megváltoztatja a szülőosztály adott metódusának viselkedését
      - Szignatúra ugyanaz
      - Ősosztály szerinti átadás és használat
        
        Hívandó függvény implementáció eldöntése
        
        Dinamikus kötés (late binding) futási időben,
        ha az alábbiak mindegyike igaz:
        
        a metódus virtual
        és
        
        a hívás szülőtípusú pointeren vagy referencián történik
        és
        
        az objektum típusa gyerektípus
        
        Ekkor valósul meg a polimorfizmus.
        
        Statikus kötés (early binding) fordítási időben,
        ha az alábbiak valamelyike igaz:
        
        a metódus nem virtual
        vagy
        
        a hívás nem polimorfikus (pl. érték szerinti)
        vagy
        
        a pointer/referencia nem szülőtípusú
        
        Érték szerint átadáskor object slicing történik, vagyis a példány gyerek része elvész!
        
        virtual
        
        Ha egyszer kiírtuk, bárhányszor származtatjuk le, virtuális marad a gyerekosztályban, tehát az ő gyereke is felüldefiniálhatja a virtual kiírása nélkül (megakadályozható a final-el)
        
        override
        
        Tagfüggvény leszármaztatáskor meg kell egyeznie a szignatúrának, vagyis a...
        
        ...névnek
        
        ...paraméterlistának (az alapértékeket leszámítva)
        
        ...const meglétének vagy hiányának
        
        ...referencia minősítésnek
        
        ...noexcept specifikációnak
        
        ...visszatérési típusnak
        (kivéve, ha az kovariáns, vagyis ha a szülőosztályban szülőtípusra-, a gyerekosztályban gyerektípusra mutató referenciát vagy pointert adunk meg)
        
        Nem muszály kiírni, de segít
        
        Adott a következő osztályunk:
        class Parent { public: virtual explicit operator string() const { return "Parent"; } virtual ~Parent() {} }; // destruktort is érdemes virtuálissá tenni class Child { public: explicit operator string() const override { return "Child"; } ~Child() override {} }; // override nem kötelező sehova se, de segít
        
        konstruktor létrejön
        
        destruktort csináltam
        
        int main() { Parent inst = Child(); cout static_cast<string>(inst); // eredmény: Parent return 0; }
        
        Tehát ez nem jó
        
        Object slicing lesz, így a példány Child része elvész
        
        int main() { Child inst = Child(); Parent& inst_ref = inst; cout static_cast<string>(inst_ref); // eredmény: Child return 0; }
        
        Így működik
        
        a Child inst átadható Parent példányt váró függvénynek
        
        int main() { Parent *inst = Child(); cout static_cast<string>(*inst); // eredmény: Child delete inst; return 0; }
        
        Így is jó
    - - tiltja a leszármaztatást
      - használható osztályra és tagfüggvényre
  - - - Lehet const és virtual
    - - Nem lehet const vagy virtual
      - Nem hivatkozhat this-re
- - - - cout << UINT_MAX + 1 << endl; // 0 (OK)
      - cout << INT_MAX + 1 << endl; // -2147483648 // (nem ajánlott, warningot dobhat, de nem hiba)
- - - - Forrás fájlok
        
        .cpp
        
        .C
        
        .cxx
        
        .cc
        
        .c++
    - - Header fájlok
        
        .h
        
        .hxx
        
        Egy header fájlon belül több osztály lehet