III. fejezet - Objektum-orientált programozás C++ nyelven

A fentiekben láttuk, hogy az osztályok alapvetően jellemzőkből (állapot) és metódusokból (viselkedés) épülnek fel. Azonban az objektumok állapotát és viselkedését két csoportba osztjuk. Lehetnek olyan jellemzők és metódusok, melyeket elfedünk más objektumok elől, mintegy belső, privát (private, védett - protected) állapotot és viselkedést létrehozva. Másokat azonban nyilvánossá (public) teszünk. Az OOP alapelveinek megfelelően az állapotjellemzőket privát eléréssel kell megadnunk, míg a metódusok többsége nyilvános lehet. Szükség esetén a privát jellemzők ellenőrzött elérésére nyilvános metódusokat készíthetünk.

Általában is elmondhatjuk, hogy egy objektum belső világának ismeretére nincs szüksége annak az objektumnak, amelyik üzenetet küld. Például, a Teherautó rendelkezik a Fékez() metódussal, amely pontosan definiálja, miként megy végbe a fékezés. Az énAutóm vezetőjének azonban nem kell ismernie, hogyan is fékez a kocsi.

Minden objektum egy jól meghatározott interfészt biztosít a külvilág számára, amely megadja, hogy kívülről mi érhető el az objektumból. Az interfész rögzítésével az objektumot használó, ügyfél alkalmazások számára semmilyen problémát sem jelent az osztály belső világának jövőbeni megváltoztatása. Így például egy interfészen keresztül biztosíthatjuk, hogy pótkocsikat csak a Kamion osztály objektumaihoz kapcsoljunk.

Öröklés során egy osztály specializált változatait hozzuk létre, amelyek öröklik a szülőosztály (alaposztály) jellemzőit és viselkedését, majd pedig sajátként használják azokat. Az így keletkező osztályokat szokás alosztályoknak (subclass), vagy származtatott (derived) osztályoknak hívni.

Például, a Teherautó osztályból származtathatjuk a Kisteherautó és a Kamion alosztályokat. Az énAutóm ezentúl legyen a Kamion osztály példánya! Tegyük fel továbbá, hogy a Teherautó osztály definiálja a Fékez() metódust és az fékrendszer tulajdonságot! Minden ebből származtatott osztály (Kisteherautó és a Kamion) örökli ezeket a tagokat, így a programozónak csak egyszer kell megírnia a hozzájuk tartozó kódot.

III.2. ábra - Az öröklés menete

Az alosztályok meg is változtathatják az öröklött tulajdonságokat. Például, a Kisteherautó osztály előírhatja, hogy a maximális terhelése 20 tonna. A Kamion alosztály pedig az EBS fékezést teheti alapértelmezetté a Fékez() metódusa számára.

A származtatott osztályokat új tagokkal is bővíthetjük. A Kamion osztályhoz adhatunk egy Navigál() metódust. Az elmondottak alapján egy adott Kamion példány Fékez() metódusa EBS alapú fékezést alkalmaz, annak ellenére, hogy a Teherautó osztálytól egy hagyományos Fékez() metódust örökölt; rendelkezik továbbá egy új Navigál() metódussal, ami azonban nem található meg a Kisteherautó osztályban.

Az öröklés valójában „egy” (is-a) kapcsolat: az énAutóm egy Kamion, a Kamion pedig egy Teherautó. Így az énAutóm egyaránt rendelkezik a Kamion és a Teherautó metódusaival.

A fentiekben mindkét származtatott osztálynak pontosan egy közvetlen szülő ősosztálya volt, a Teherautó. Ezt az öröklési módot egyszeres öröklésnek (single inheritance) nevezzük, megkülönböztetve a többszörös örökléstől.

A többszörös öröklés (multiple inheritance) folyamán a származtatott osztály, több közvetlen ősosztály tagjait örökli. Például, egymástól teljesen független osztályokat definiálhatunk Teherautó és Hajó néven. Ezekből pedig örökléssel létrehozhatunk egy Kétéltű osztályt, amely egyaránt rendelkezik a teherautók és hajók jellemzőivel és viselkedésével. A legtöbb programozási nyelv (ObjectPascal, Java, C#) csak az egyszeres öröklést támogatja, azonban a C++-ban mindkét módszer alkalmazható.

III.3. ábra - Többszörös öröklés

Az elvonatkoztatás a probléma megfelelő osztályokkal való modellezésével egyszerűsíti az összetett valóságot, valamint a probléma - adott szempontból - legmegfelelőbb öröklési szintjén fejti ki hatását. Például, az énAutóm az esetek nagy többségében Teherautóként kezelhető, azonban lehet Kamion is, ha szükségünk van a Kamion specifikus jellemzőkre és viselkedésre, de tekinthetünk rá Járműként is, ha egy flotta elemeként vesszük számba. (A Jármű a példában a Teherautó szülő osztálya.)

Az absztrakcióhoz a kompozíción keresztül is eljuthatunk. Például, egy Autó osztálynak tartalmaznia kell egy motor, sebességváltó, kormánymű és egy sor más komponenst. Ahhoz, hogy egy Autót felépítsünk, nem kell tudnunk, hogyan működnek a különböző komponensek, csak azt kell ismernünk, miként kapcsolódhatunk hozzájuk (interfész). Az interfész megmondja, miként küldhetünk nekik, illetve fogadhatunk tőlük üzenetet, valamint információt ad arról, hogy az osztályt alkotó komponensek milyen kölcsönhatásban vannak egymással.

A polimorfizmus lehetővé teszi, hogy az öröklés során bizonyos (elavult) viselkedési formákat (metódusokat) a származtatott osztályban új tartalommal valósítsunk meg, és az új, lecserélt metódusokat a szülő osztály tagjaiként kezeljük.

Példaként tegyük fel, hogy a Teherautó és a Kerekpár osztályok öröklik a Jármű osztály Gyorsít() metódusát. A Teherautó esetén a Gyorsít() parancs a GáztAd() műveletet jelenti, míg Kerekpár esetén a Pedáloz() metódus hívását. Ahhoz, hogy a gyorsítás helyesen működjön, a származtatott osztályok Gyorsít() metódusával felül kell bírálnunk (override) a Jármű osztálytól örökölt Gyorsít() metódust. Ez a felülbíráló polimorfizmus.

A legtöbb OOP nyelv a parametrikus polimorfizmust is támogatja, ahol a metódusokat típusoktól független módon, mintegy mintaként készítjük el a fordító számára. A C++ nyelven sablonok (templates) készítésével alkalmazhatjuk ezt a lehetőséget.

Valamely feladat megoldásához szükséges adatokat már eddigi ismereteinkkel is össze tudjuk fogni a struktúra típus alkalmazásával, amennyiben az adatok tárolására a struktúra tagjait használjuk:

struct Alkalmazott{
    int torzsszam;
    string nev;
    float fizetes;
};

Sőt műveleteket is definiálhatunk függvények formájában, amelyek argumentumként megkapják a struktúra típusú változót:

void BertEmel(Alkalmazott& a, float szazalek) {
    a.ber *= (1 + szazalek/100);
}

A struktúra tagjait a pont, illetve a nyíl operátorok segítségével érhetjük el, attól függően, hogy a fordítóra bízzuk a változó létrehozását, vagy pedig magunk gondoskodunk a területfoglalásról:

int main() {
    Alkalmazott mernok;
    mernok.torzsszam = 1234;
    mernok.nev = "Okos Antal";
    mernok.ber = 2e5;
    BertEmel(mernok,12);
    cout << mernok.ber << endl;
 
    Alkalmazott *pKonyvelo = new Alkalmazott;
    pKonyvelo->torzsszam = 1235;
    pKonyvelo->nev = "Gazdag Reka";
    pKonyvelo->ber = 3e5;
    BertEmel(*pKonyvelo,10);
    cout << pKonyvelo->ber << endl;
    delete pKonyvelo;
}

Természetesen a fent bemutatott módon is lehet strukturált felépítésű, hatékony programokat fejleszteni, azonban ebben a fejezetben mi tovább megyünk.

Első lépésként - a bezárás elvének (encapulation) megfelelően - az adatokat és a rajtuk elvégzendő műveleteket egyetlen programegysége foglaljuk, azonban ezt a programegységet már, bár struktúra osztálynak nevezzük.

struct Alkalmazott {
    int torzsszam;
    string nev;
    float ber;
    void BertEmel(float szazalek) {
        ber *= (1 + szazalek/100);
    }
};

Első látásra feltűnik, hogy a BertEmel() függvény nem kapja meg paraméterként az osztály típusú változót (objektumot), hiszen alapértelmezés szerint az objektumon végez műveletet. Az Alkalmazott típusú objektumok használatát bemutató main () függvény is valamelyest módosult, hiszen most már a változóhoz tartozó tagfüggvényt hívjuk:

int main() {
    Alkalmazott mernok;
    mernok.torzsszam = 1234;
    mernok.nev = "Okos Antal";
    mernok.ber = 2e5;
    mernok.BertEmel(12);
    cout << mernok.ber << endl;
 
    Alkalmazott *pKonyvelo = new Alkalmazott;
    pKonyvelo->torzsszam = 1235;
    pKonyvelo->nev = "Gazdag Reka";
    pKonyvelo->ber = 3e5;
    pKonyvelo->BertEmel(10);
    cout << pKonyvelo->ber << endl;
    delete pKonyvelo;
}

Az osztály típusú változók (objektumok) adattagjainak közvetlen elérése ellentmond az adatrejtés elvének. Objektum-orientált megoldásoknál kívánatos, hogy az osztály adattagjait ne lehessen közvetlenül elérni az objektumon kívülről. A struct típus alaphelyzetben teljes elérhetőséget biztosít a tagjaihoz, míg a class típus teljesen elzárja a tagjait a külvilág elől, ami sokkal inkább megfelel az objektum-orientált elveknek. Felhívjuk a figyelmet arra, hogy az osztályelemek elérhetőségét a private, protected és public kulcsszavak segítségével magunk is szabályozhatjuk.

A public tagok bárhonnan elérhetők a programon belül, ahonnan maga az objektum elérhető. Ezzel szemben a private tagokhoz csak az osztály saját tagfüggvényeiből férhetünk hozzá. (A protected elérést a III.3. szakasz tárgyalt öröklés során alkalmazzuk.)

Az osztályon belül tetszőleges számú tagcsoportot kialakíthatunk az elérési kulcsszavak (private, protected, public) alkalmazásával, és a csoportok sorrendjére sincs semmilyen megkötés.

A fenti példánknál maradva, a korlátozott elérés miatt szükséges további tagfüggvényeket megadnunk, amelyekkel ellenőrzött módon beállíthatjuk (set), illetve lekérdezhetjük (get) az adattagok értékét. A beállító függvényekben a szükséges ellenőrzéseket is elvégezhetjük, így csak érvényes adat fog megjelenni az Alkalmazott típusú objektumokban. A lekérdező függvényeket általában konstansként adjuk meg, ami azt jelöli, hogy nem módosítjuk az adattagok értékét a tagfüggvényből. Konstans tagfüggvényben a függvény feje és törzse közé helyezzük a const foglalt szót. Példánkban a GetBer() konstans tagfüggvény.

class Alkalmazott{
  private:
    int torzsszam;
    string nev;
    float ber;
  public:
    void BertEmel(float szazalek) {
        ber *= (1 + szazalek/100);
    }
    void SetAdatok(int tsz, string n, float b) {
        torzsszam = tsz;
        nev = n;
        ber = b;
    }
    float GetBer() const {
        return ber;
    }
};
 
int main() {
    Alkalmazott mernok;
    mernok.SetAdatok(1234, "Okos Antal", 2e5);
    mernok.BertEmel(12);
    cout << mernok.GetBer() << endl;
 
    Alkalmazott *pKonyvelo = new Alkalmazott;
    pKonyvelo->SetAdatok(1235, "Gazdag Reka", 3e5);
    pKonyvelo->BertEmel(10);
    cout << pKonyvelo->GetBer() << endl;
    delete pKonyvelo;
}

Megjegyezzük, hogy a konstans tagfüggvényekből is megváltoztathatunk adattagokat, amennyiben azokat a mutable (változékony) kulcsszóval deklaráljuk, például:

mutable float ber;

Az ilyen megoldásokat azonban igen ritkán alkalmazzuk.

Megjegyezzük, ha egy osztály minden adattagja nyilvános elérésű, akkor az objektum inicializálására a struktúráknál bemutatott megoldást is használhatjuk, például:

Alkalmazott portas = {1122, "Biztos Janos", 1e5};

Mivel a későbbiek folyamán a fenti forma használhatóságát további megkötések korlátozzák (nem lehet származtatott osztály, nem lehetnek virtuális tagfüggvényei), ajánlott az inicializálást az osztályok speciális tagfüggvényeivel, az ún. konstruktorokkal elvégezni.

Az osztályokat használó programokban egyik leggyakoribb művelet az objektumok létrehozása. Az objektumok egy részét mi hozzuk részre statikus vagy dinamikus helyfoglalással (lásd fent), azonban vannak olyan esetek is, amikor a fordítóprogram készít ún. ideiglenes objektumpéldányokat. Hogyan gondoskodhatunk a megszülető objektumok adattagjainak kezdőértékkel való (automatikus) ellátásáról? A választ a konstruktornak nevezett tagfüggvények bevezetésével találjuk meg.

class Alkalmazott{
  private:
    int torzsszam;
    string nev;
    float ber;
  public:
    Alkalmazott() {                           // default
        torzsszam = 0;
        nev = "";
        ber = 0;
    }
    Alkalmazott(int tsz, string n, float b) { // paraméteres
        torzsszam = tsz;
        nev = n;
        ber = b;
    }
    Alkalmazott(const Alkalmazott & a) {      // másoló 
        torzsszam = a.torzsszam;
        nev = a.nev;
        ber = a.ber;
    }
    void BertEmel(float szazalek) {
        ber *= (1 + szazalek/100);
    }
    void SetNev(string n) {
        nev = n;
    }
    float GetBer() const {
        return ber;
    }
};
 
int main() {
    Alkalmazott dolgozo;
    dolgozo.SetNev("Kiss Pista");
 
    Alkalmazott mernok(1234, "Okos Antal", 2e5);
    mernok.BertEmel(12);
    cout << mernok.GetBer() << endl;
 
    Alkalmazott fomernok = mernok;
    // vagy: Alkalmazott fomernok(mernok);
    fomernok.BertEmel(50);
    cout << fomernok.GetBer() << endl;
 
    Alkalmazott *pDolgozo = new Alkalmazott;
    pDolgozo->SetNev("Kiss Pista");
    delete pDolgozo;
 
    Alkalmazott *pKonyvelo;
    pKonyvelo = new Alkalmazott(1235, "Gazdag Reka", 3e5);
    pKonyvelo->BertEmel(10);
    cout << pKonyvelo->GetBer() << endl;
    delete pKonyvelo;
 
    Alkalmazott *pFomernok=new Alkalmazott(mernok);
    pFomernok->BertEmel(50);
    cout << pFomernok->GetBer() << endl;
    delete pFomernok;
}

A fenti példában – a függvénynevek túlterhelését alkalmazva - készítettünk egy paraméter nélküli, egy paraméteres és egy másoló konstruktort. Látható, hogy a konstruktor olyan tagfüggvény, amelynek neve megegyezik az osztály nevével, és nincs visszatérési típusa. Az osztály konstruktorát a fordító minden olyan esetben automatikusan meghívja, amikor az adott osztály objektuma létrejön. A konstruktor nem rendelkezik visszatérési értékkel, de különben ugyanúgy viselkedik, mint bármely más tagfüggvény. A konstruktor átdefiniálásával (túlterhelésével) többféleképpen is inicializálhatjuk az objektumokat.

A konstruktor nem foglal tárterületet a létrejövő objektum számára, feladata a már lefoglalt adatterület inicializálása. Ha azonban az objektum valamilyen mutatót tartalmaz, akkor a konstruktorból kell gondoskodnunk a mutató által kijelölt terület lefoglalásáról.

Egy osztály alapértelmezés szerint két konstruktorral rendelkezik: a paraméter nélküli (default) és a másoló konstruktorral. Ha valamilyen saját konstruktort készítünk, akkor a paraméter nélküli alapértelmezett (default) konstruktor nem érhető el, így azt is definiálnunk kell. Saját másoló konstruktort általában akkor használunk, ha valamilyen dinamikus tárterület tartozik az osztály példányaihoz.

A paraméter nélküli és a paraméteres konstruktort gyakran összevonjuk az alapértelmezés szerinti argumentumok bevezetésével:

class Alkalmazott{
  private:
    int torzsszam;
    string nev;
    float ber;
  public:
    Alkalmazott(int tsz = 0, string n ="", float b=0) {
        torzsszam = tsz;
        nev = n;
        ber = b;
    }
    …
}

class Alkalmazott{
  private:
    int torzsszam;
    string nev;
    float ber;
  public:
    Alkalmazott(int tsz=0, string n="", float b=0) 
        : torzsszam(tsz), nev(n), ber(b) { }
    Alkalmazott(const Alkalmazott & a) 
        : torzsszam(a.torzsszam), nev(a.nev),  
          ber(a.ber) { }
    …
}

class Szam 
{
  private:
    int n;
  public:
    explicit Szam( int x) {
        n = x;
        cout << "int: " << n << endl;
    }
    Szam( float x) {
        n = x < 0 ? int(x-0.5) : int(x+0.5);
        cout << "float: " << n << endl;
    }
};
 
int main() {
  Szam a(123);    // explicit hívás
  Szam b = 123;   // implicit (nem explicit) hívás
}

Gyakran előfordul, hogy egy objektum létrehozása során erőforrásokat (memória, állomány stb.) foglalunk le, amelyeket az objektum megszűnésekor fel kell szabadítanunk. Ellenkező esetben ezek az erőforrások elvesznek a programunk számára.

A C++ nyelv biztosít egy speciális tagfüggvényt - a destruktort - amelyben gondoskodhatunk a lefoglalt erőforrások felszabadításáról. A destruktor nevét hullám karakterrel (~) egybeépített osztálynévként kell megadni. A destruktor, a konstruktorhoz hasonlóan nem rendelkezik visszatérési típussal.

Az alábbi példában egy 12-elemű, dinamikus helyfoglalású tömböt hozunk létre a konstruktorokban, az alkalmazottak havi munkaidejének tárolására. A tömb számára lefoglalt memóriát a destruktorban szabadítjuk fel.

class Alkalmazott{
  private:
    int torzsszam;
    string nev;
    float ber;
    int *pMunkaorak;
  public:
    Alkalmazott(int tsz = 0, string n ="", float b=0) {
        torzsszam = tsz;
        nev = n;
        ber = b;
        pMunkaorak = new int[12];
        for (int i=0; i<12; i++) pMunkaorak[i]=0;
    }
    Alkalmazott(const Alkalmazott & a) {
        torzsszam = a.torzsszam;
        nev = a.nev;
        ber = a.ber;
        pMunkaorak = new int[12];
        for (int i=0; i<12; i++) 
            pMunkaorak[i]=a.pMunkaorak[i];
    }
    ~Alkalmazott() {
        delete[] pMunkaorak;
        cout << nev << " torolve" << endl;
    }
    void BertEmel(float szazalek) {
        ber *= (1 + szazalek/100);
    }
    void SetMunkaora(int honap, int oraszam) {
        if (honap >= 1 && honap <=12) {
            pMunkaorak[honap-1]=oraszam;
        }
    }
    float GetBer() const {
        return ber;
    }
};
 
int main() {
    Alkalmazott mernok(1234, "Okos Antal", 2e5);
    mernok.BertEmel(12);
    mernok.SetMunkaora(3,192);
    cout << mernok.GetBer() << endl;
 
    Alkalmazott *pKonyvelo;
    pKonyvelo = new Alkalmazott(1235, "Gazdag Reka", 3e5);
    pKonyvelo->BertEmel(10);
    pKonyvelo->SetMunkaora(1,160);
    pKonyvelo->SetMunkaora(12,140);
    cout << pKonyvelo->GetBer() << endl;
    delete pKonyvelo;
}

A lefordított program minden olyan esetben meghívja az osztály destruktorát, amikor az objektum érvényessége megszűnik. Kivételt képeznek a new operátorral dinamikusan létrehozott objektumok, melyek esetén a destruktort csak a delete operátor segítségével aktivizálhatjuk. Fontos megjegyeznünk, hogy a destruktor nem magát az objektumot szűnteti meg, hanem automatikusan elvégez néhány általunk megadott „takarítási” műveletet.

A példaprogram futtatásakor az alábbi szöveg jelenik meg:

224000
330000
Gazdag Reka torolve
Okos Antal torolve

Ebből láthatjuk, hogy először a *pKonyvelo objektum destruktora hívódik meg a delete operátor használatakor. Ezt követően a main () függvény törzsét záró kapcsos zárójel elérésekor automatikusan aktiválódik a mernok objektum destruktora.

Amennyiben nem adunk meg destruktort, a fordítóprogram automatikusan egy üres destruktorral látja el az osztályunkat.

Amikor az Alkalmazott osztálytípussal objektumokat (osztály típusú változókat) hozunk létre:

Alkalmazott mernok(1234, "Okos Antal", 2e5);
Alkalmazott *pKonyvelo;
pKonyvelo = new Alkalmazott(1235, "Gazdag Reka", 3e5);

minden objektum saját adattagokkal rendelkezik, azonban a tagfüggvények egyetlen példányát megosztva használják (III.4. ábra).

mernok.BertEmel(12);
pKonyvelo->BertEmel(10);

Felvetődik a kérdés, honnan tudja például a BertEmel() függvény, hogy a hívásakor mely adatterületet kell elérnie?

Erre a kérdésre a fordító nem látható tevékenysége adja meg a választ: minden tagfüggvény, még a paraméter nélküliek is, rendelkeznek egy nem látható paraméterrel (this), amelyben a hívás során az aktuális objektumra mutató pointer adódik át a függvénynek. A fentieken kívül minden adattag-hivatkozás automatikusan az alábbi formában kerül be a kódba:

this->adattag

III.4. ábra - Az Alkalmazott osztály és az objektumai

A this (ez) mutatót mi is felhasználhatjuk a tagfüggvényeken belül. Ez a lehetőség jól jön, amikor egy paraméter neve megegyezik valamely adattag nevével:

class Alkalmazott{
  private:
    int torzsszam;
    string nev;
    float ber;
  public:
    Alkalmazott(int torzsszam=0, string nev="", float ber=0){
        this->torzsszam = torzsszam;
        this->nev = nev;
        this->ber = ber;
    }
};

A this mutató deklarációja normál tagfüggvények esetén Osztálytípus* constthis, illetve const Osztálytípus*const this a konstans tagfüggvényekben.

C++ nyelven az osztályok adattagjai előtt megadhatjuk a static kulcsszót, jelezve azt, hogy ezeket a tagokat (a tagfüggvényekhez hasonlóan) megosztva használják az osztály objektumai. Az egyetlen példányban létrejövő statikus adattag közvetlenül az osztályhoz tartozik, így az akkor is elérhető, ha egyetlen objektuma sem létezik az osztálynak.

A statikus adattag inicializálását az osztályon kívül kell elvégezni (függetlenül az adattag elérhetőségétől). Kivételt képeznek a static const egész és felsorolás típusú adattagok, melyek kezdőértéke az osztályon belül is megadható.

Ha a statikus adattag nyilvános elérésű, akkor a programban bárhonnan felhasználhatjuk az osztály neve és a hatókör (::) operátor magadásával. Ellenkező esetben csak az osztály példányai érik el ezeket a tagokat.

Az alábbi példában a statikus tagok használatának bemutatásán túlmenően, a konstansok osztályban való elhelyezésének megoldásait (static const és enum) is szemléltetjük. Az általunk definiált matematikai osztály (Math) lehetővé teszi, hogy a Sin() és a Cos() tagfüggvényeket radián vagy fok mértékegységű adatokkal hívjuk:

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
 
class Math {
  public:
    enum Egyseg {fok, radian};
  private:
    static double dFok2Radian;
    static Egyseg eMode;
  public:
    static const double Pi;
 
    static double Sin(double x)
           {return sin(eMode == radian ? x : dFok2Radian*x);}
    static double Cos(double x)
           {return cos(eMode == radian ? x : dFok2Radian*x);}
    static void Mertekegyseg(Egyseg mode = radian) { 
                                          eMode = mode; }
    void KiirPI() { cout.precision(18); cout<<Pi<<endl;}
};
 
// A statikus adattagok létrehozása és inicializálása
const double Math::Pi = M_PI;
double Math::dFok2Radian = Math::Pi/180;
Math::Egyseg Math::eMode = Math::radian;

A példában látható módon, az osztályon belül egy felsorolást is elhelyezhetünk. Az így elkészített Egyseg típusnévre és a felsorolt (fok, radian) konstansokra az osztálynévvel minősített név segítségével hivatkozhatunk. Ezek a nevek osztály hatókörrel rendelkeznek, függetlenül az enum kulcsszó után megadott típusnévtől (Math::Egyseg): Math::radian, Math::fok.

A statikus adattagok kezelésére általában statikus tagfüggvényeket használunk (Math::Sin(), Math::Cos(), Math::Mertekegyseg()). A statikus tagfüggvényekből azonban a normál adattagokhoz nem férhetünk hozzá, mivel a paramétereik között nem szerepel a this mutató. A nem statikus tagfüggvényekből az osztály statikus tagjait korlátozás nélkül elérhetjük.

A Math osztály lehetséges alkalmazását az alábbiakban láthatjuk:

int main() {
   double y = Math::Sin(Math::Pi/6);  // radiánban számol
   Math::Mertekegyseg(Math::fok);     // fokokban számol
   y = Math::Sin(30);
   Math::Mertekegyseg(Math::radian);  // radiánban számol
   y = Math::Sin(Math::Pi/6);
 
   Math m;                            // oszálypéldány
   m.Mertekegyseg(Math::fok);         // vagy
   m.Mertekegyseg(m.fok);
   y = m.Sin(30);
   m.Mertekegyseg(m.radian);          // vagy
   m.Mertekegyseg(Math::radian);
   y = m.Sin(Math::Pi/6);
   m.KiirPI();
}

A C++ nyelv szabályai többféle osztálykialakítási megoldást is lehetővé tesznek. Az alábbi példákban szigorúan elkülönítjük az egyes eseteket, azonban a programozási gyakorlatban ezeket vegyesen használjuk.

class Pont {
   private:
      int x,y;
   public:
      Pont(int a = 0, int b = 0) { x = a; y = b; }
      int GetX() const { return x; }
      int GetY() const { return y; }
      void SetX(int a) { x = a; }
      void SetY(int a) { y = a; }
      void Mozgat(int a, int b) { x = a; y = b; }
      void Mozgat(const Pont& p) { x = p.x; y = p.y; }
      void Kiir() const { cout<<"("<<x<<","<<y<<")\n"; }
};

class Pont {
   private: int x,y;
   public: Pont(int a = 0, int b = 0) { x = a; y = b; }
   public: int GetX() const { return x; }
   public: int GetY() const { return y; }
   public: void SetX(int a) { x = a; }
   public: void SetY(int a) { y = a; }
   public: void Mozgat(int a, int b) { x = a; y = b; }
   public: void Mozgat(const Pont& p) { x = p.x; y = p.y; }
   public: void Kiir() const { cout<<"("<<x<<","<<y<<")\n"; }
};

#ifndef __PONT_H__
#define __PONT_H__
 class Pont {
   private:
      int x,y;
   public:
      Pont(int a = 0, int b = 0);
      int GetX() const;
      int GetY() const;
      void SetX(int a);
      void SetY(int a);
      void Mozgat(int a, int b);
      void Mozgat(const Pont& p);
      void Kiir() const;
 };
#endif

#include <iostream>
using namespace std;
#include "Pont.h"
 
Pont::Pont(int a, int b) { 
   x = a; y = b;
}            
 
int Pont::GetX() const {
   return x; 
} 
 
int Pont::GetY() const {
   return y; 
} 
 
void Pont::SetX(int a) {
   x = a; 
}
 
void Pont::SetY(int a) {
   y = a; 
}
 
void Pont::Mozgat(int a, int b) { 
   x = a; y = b; 
}            
 
void Pont::Mozgat(const Pont& p) {
   x = p.x; y = p.y; 
}
 
void Pont::Kiir() const {
   cout<<"("<<x<<","<<y<<")\n"; 
}

#ifndef __PONT_H__
#define __PONT_H__
class Pont {
   private:
      int x,y;
   public:
      Pont(int a = 0, int b = 0);
      int GetX() const;
      int GetY() const;
      void SetX(int a);
      void SetY(int a);
      void Mozgat(int a, int b);
      void Mozgat(const Pont& p);
      inline void Kiir() const;
};
 
void Pont::Kiir() const {
   cout<<"("<<x<<","<<y<<")\n";
 }
 
#endif

Vannak esetek, amikor a C++ nyelv adatrejtés szabályai megakadályozzák, hogy hatékony programkódot készítsünk.  A friend (barát) mechanizmus azonban lehetővé teszi, hogy egy osztály private és protected tagjait az osztályon kívüli függvényekből is elérjük.

A friend deklarációt az osztály leírásán belül, tetszőleges elérésű részben elhelyezhetjük. A „barát” lehet egy külső függvény, egy másik osztály adott tagfüggvénye, de akár egy egész osztály is (vagyis annak minden tagfüggvénye). Ennek megfelelően a friend deklarációban a függvények prototípusát, illetve az osztály nevét szerepeltetjük a class szóval bevezetve.

Felhívjuk a figyelmet arra, hogy barátosztály esetén a „baráti viszony” nem kölcsönös, vagyis csak a friend deklarációban szereplő osztály tagfüggvényei kapnak korlátlan elérést a leírást tartalmazó osztály tagjaihoz.

Az alábbi példában szereplő COsztaly minden tagját korlátozás nélkül eléri a külső Osszegez() függvény, a BOsztaly Szamlal() nyilvános tagfüggvénye valamint az AOsztaly minden tagfüggvénye:

class AOsztaly;
 
class BOsztaly {
 public:
  int Szamlal(int x) { return x++; }
};
 
class COsztaly {
  friend long Osszegez(int a, int b);
  friend int BOsztaly::Szamlal(int x);
  friend class AOsztaly;
  // ...
};
 
long Osszegez(int a, int b) {
  return long(a) + b;
}

További példaként tekintsük a síkbeli pontok leírásához használható egyszerűsített Pont osztályunkat! Mivel a pontok távolságát számító művelet eredménye nem kapcsolható egyik ponthoz sem, így a távolság meghatározására külső függvényt készítünk, amely argumentumként kapja a két pontot. Az adattagok gyors eléréséhez azonban szükséges a közvetlen hozzáférés biztosítása, ami a „barát” mechanizmus révén meg is valósítható.

#include <iostream>
#include <cmath>
using namespace std;
 
class Pont {
      friend double Tavolsag(const Pont & p1,
                             const Pont & p2);
   private:
      int x,y;
   public:
      Pont(int a = 0, int b = 0) { x = a; y = b; }
      int GetX() const { return x; }
      int GetY() const { return y; }
      void SetX(int a) { x = a; }
      void SetY(int a) { y = a; }
      void Mozgat(int a, int b) { x = a; y = b; }
      void Mozgat(const Pont& p) { x = p.x; y = p.y; }
      void Kiir() const { cout<<"("<<x<<","<<y<<")\n"; }
};
 
double Tavolsag(const Pont & p1, const Pont & p2) {
  return sqrt(pow(p1.x-p2.x,2.0)+pow(p1.y-p2.y,2.0));
}
 
int main() {
  Pont p, q;
  p.Mozgat(1,2);
  q.Mozgat(4,6);
  cout<<Tavolsag(p,q)<<endl;
}

Az osztályokkal történő eddigi ismerkedésünk során adatokat és függvényeket helyeztünk el az osztályokban. A statikus tagok esetén ezt a sort a statikus konstansokkal és az enum típussal bővítettük.

Az alábbiakban először megnézzük, miként helyezhetünk el az osztályunkban konstanst és hivatkozást, ezt követően pedig röviden áttekintjük az ún. egymásba ágyazott osztályok használatával kapcsolatos szabályokat.

class Felhasznalo {
    string jelszo;
 public:
    const string nev;
    Felhasznalo(string user, string psw="") : nev(user) {
         jelszo=psw;
    }
    void SetJelszo(string newpsw) { jelszo = newpsw;}
};
 
int main() {
   Felhasznalo nata("Lafenita");
   Felhasznalo kertesz("Liza");
   nata.SetJelszo("Atinefal1223");
   kertesz.SetJelszo("Azil729");
   cout<<nata.nev<<endl;
   cout<<kertesz.nev<<endl;
   Felhasznalo alias = nata;
   // alias = kertesz;   // hiba!
}

class Jelado {
   private:
      int adat;
   public:
     Jelado(int x) { adat = x; }
     int Olvas() { return adat; }
};
 
class Vezerlo {
   private:
     Jelado& jelado;
   public:
     Vezerlo(Jelado& szenzor) : jelado(szenzor) {}
     void AdatotFogad() { cout<<jelado.Olvas(); }
};
 
int main() {
   Jelado sebesseg(0x17);
   Vezerlo ABS(sebesseg);
   ABS.AdatotFogad();
}

class Jelado {
   private:
      int adat;
   public:
     Jelado(int x) { adat = x; }
     int Olvas() { return adat; }
};
 
class Vezerlo {
   private:
     Jelado jelado;
   public:
     Vezerlo() : jelado(0x17) {}
     void AdatotFogad() { cout<<jelado.Olvas(); }
};
 
int main() {
   Vezerlo ABS;
   ABS.AdatotFogad();
}

C++-ban egy függvényre mutató pointer még akkor sem veheti fel valamely tagfüggvény címét, ha különben a típusuk és a paraméterlistájuk teljesen megegyezik. Ennek oka, hogy a (nem statikus) tagfüggvények az osztály példányain fejtik ki hatásukat. Ugyanez igaz az adattagokhoz rendelt mutatókra is. (További fontos eltérés a hagyományos mutatókhoz képest, hogy a virtuális tagfüggvények mutatón keresztüli hívása esetén is érvényesül a későbbiekben tárgyalt polimorfizmus.)

A mutatók helyes definiálásához az osztály nevét és a hatókör operátort is alkalmaznunk kell:

A következő példában bemutatjuk az osztálytagokra mutató pointerek használatát, melynek során mindkét osztálytagot mutatók segítségével érjük el. Az ilyen mutatók alkalmazása esetén a tagokra a szokásos operátorok helyett a .* (pont csillag), illetve a ->* (nyíl csillag) operátorokkal hivatkozhatunk. Az adattagok és tagfüggvények címének lekérdezéséhez pedig egyaránt a címe (&) operátort kell használnunk.

#include <iostream>
using namespace std;
 
class Osztaly {
  public:
    int a;
    void f(int b) { a += b;}
};
 
int main() {
   // mutató az Osztaly int típusú adattagjára
   int Osztaly::*intptr = &Osztaly::a;
 
   // mutató az Osztaly void típusú, int paraméterű 
   // tagfüggvényére
   void (Osztaly::* fvptr)(int) = &Osztaly::f;
 
   // az objektupéldányok létrehozása
   Osztaly objektum;
   Osztaly * pobjektum = new Osztaly();
 
   // az a adattag elérése mutató segítségével
   objektum.*intptr = 10;
   pobjektum->*intptr = 100;
 
   // az f() tagfüggvény hívása pointer felhasználásával
   (objektum.*fvptr)(20);
   (pobjektum->*fvptr)(200);
 
   cout << objektum.a << endl;     // 30
   cout << pobjektum->a << endl;    // 300
   delete pobjektum;
}

A typedef alkalmazásával egyszerűbbé tehetjük a pointeres kifejezésekkel való munkát:

typedef int Osztaly::*mutato_int;
 
typedef void (Osztaly::*mutato_fv)(int);
 
…
mutato_int intptr = &Osztaly::a;
 
mutato_fv fvptr = &Osztaly::f;

Az operátorok túlterhelését megvalósító operátorfüggvények kialakítása nagymértékben függ a kiválasztott műveleti jeltől. Az alábbi táblázatban összefoglaltuk a lehetőségeket. Az operátorfüggvények többségének visszatérési értéke és típusa szabadon megadható.

Az operátorfüggvényeket általában osztályon belül adjuk meg, a felhasználói típus lehetőségeinek kiterjesztése céljából. Az =, (), [] és -> operátorokat azonban csak nem statikus tagfüggvénnyel lehet átdefiniálni. A new és a delete operátorok esetén a túlterhelés statikus tagfüggvénnyel történik. Minden más operátorfüggvény elkészíthető tagfüggvényként vagy külső (általában friend) függvényként.

Az elmondottakat jól szemlélteti a fenti táblázat, ahol csoportokba rendeztük a C++ nyelv átdefiniálható műveleteit, a dinamikus memóriakezelés operátorainak elhagyásával. A táblázatban a ♣ karakter a műveleti jelet helyettesíti, míg az a, b és c valamely A, B és C osztály objektumai.

A túlterhelhető C++ műveleti jelek többségét az operandusok száma alapján két csoportra oszthatjuk. Erre a két esetre az alábbi táblázatban összefoglaltuk az operátorfüggvények hívásának formáit.

Kétoperandusú operátorok esetén:

Egyoperandusú operátorok esetén:

Bizonyos műveleteket átdefiniálása során a szokásostól eltérő megfontolásokra is szükség van. Ezen operátorokat a fejezet további részeiben ismertetjük.

Példaként tekintsük az egész számok tárolására alkalmas Vektor osztályt, amelyben túlterheltük az indexelés ([]), az értékadás (=) és az összeadás (+, +=) műveleteit! Az értékadás megvalósítására a tömb elemeinek másolása érdekében volt szükség. A + operátort barátfüggvénnyel valósítjuk meg, mivel a keletkező vektor logikailag egyik operandushoz sem tartozik. Ezzel szemben a += művelet megvalósításához tagfüggvényt használunk, hiszen a művelet során a bal oldali operandus elemei módosulnak. Az osztály teljes deklarációját (inline függvényekkel) a Vektor.h állomány tartalmazza.

#ifndef __VektorH__
#define __VektorH__
 
class Vektor {
inline friend Vektor  operator+ (const Vektor& v1, 
                                 const Vektor& v2);
  private:
    int meret, *p;
  public:
    // ----- Konstruktorok -----
    // Adott méretű vektor inicilaizálása
    Vektor(int n=10) {
        p = new int[meret=n];
        for (int i = 0; i < meret; ++i)  
            p[i] = 0;       // az elemek nullázása
    }
    // Inicializálás másik vektorral - másoló konstruktor
    Vektor(const Vektor& v) {
         p = new int[meret=v.meret];
         for (int i = 0; i < meret; ++i) 
            p[i] = v.p[i];   // az elemek átmásolása
    }
    // Inicializálás hagyományos n-elemu vektorral
    Vektor(const int a[], int n) {
        p = new int[meret=n];
        for (int i = 0; i < meret; ++i)
           p[i] = a[i];
    }
 
    // ----- Destruktor -----
    ~Vektor() {delete[] p; }
 
    // ----- Meretlekérdező tagfüggvény -----
    int GetMeret() const { return meret; } 
 
    // ----- Operátorfüggvények -----
    int& operator [] (int i) {
        if (i < 0 || i > meret-1)  // indexhatár-ellenőrzés
            throw i;
        return p[i];
    }
 
    const int& operator [] (int i) const {
        return p[i];
    }
 
    Vektor operator = (const Vektor& v) {
        delete[] p;
        p=new int [meret=v.meret];
        for (int i = 0; i < meret; ++i)
           p[i] = v.p[i];
        return *this;
    }
 
    Vektor operator += (const Vektor& v) {
        int m = (meret < v.meret) ? meret : v.meret;
        for (int i = 0; i < m; ++i)
           p[i] += v.p[i];
        return *this;
    }
};
 
// ----- Külső függvény  -----
inline Vektor operator+(const Vektor& v1, const Vektor& v2) {
    Vektor osszeg(v1);
    osszeg+=v2;
    return osszeg;
}
#endif

A példaprogram megértéséhez néhány megjegyzést kell fűznünk a programkódhoz.

A Vektor osztály felhasználását az alábbi programrészlet szemlélteti:

#include <iostream>
using namespace std;
#include "Vektor.h"
 
void show(const Vektor& v) {
  for (int i=0; i<v.GetMeret(); i++)
    cout<<v[i]<<'\t';
  cout<<endl;
}
 
int main() {
    int a[5]={7, 12}, b[7]={2, 7, 12, 23, 29};
    Vektor x(a,5);     // x:  7  12   0   0  0
    Vektor y(b,7);     // y:  2   7  12  23 29  0  0
    Vektor z;          // z:  0   0   0   0  0  0  0  0  0  0
    try {
       x = y;          // x:  2   7  12  23 29  0  0
       x = Vektor(a,5);// x:  7  12   0   0  0
       x += y;         // x:  9  19  12  23 29
       z = x + y;      // z: 11  26  24  46 58
       z[0] = 102;
       show(z);        // z:102  26  24  46 58
    }
    catch (int n) {
        cout<<"Hibas tombindex: "<<n<<endl;
    }
    const Vektor v(z);
    show(v);            // v:102  26  24  46 58
    // v[0] = v[1]+5;   // error: assignment of read-only…
}

A C++ nyelv támogatja, hogy osztályainkhoz típuskonverziókat rendeljünk. A felhasználó által definiált típus-átalakítást végző operátorfüggvény deklarációja:

        operator típus();

A függvény visszatérési értékének típusa megegyezik a függvény nevében szereplő típussal. A típuskonverziós operátorfüggvény csak visszatérési típus és argumentumlista nélküli tagfüggvény lehet.

Az alábbi példában a Komplex típust osztályként valósítjuk meg. Az egyetlen nem Komplex típusú argumentummal rendelkező konstruktor elvégzi a más típusról – a példában double – Komplex típusra történő konverziót. A fordított irányú átalakításhoz double nevű konverziós operátort készítünk.

#include <cmath>
#include <iostream>
using namespace std;
 
class Komplex {
  public:
    Komplex () { re=im=0; }
    Komplex(double a) : re(a), im(0) { }
    // konverziós konstruktor
    Komplex(double a, double b) : re(a), im(b) { }
    // konverziós operátor
    operator double() {return sqrt(re*re+im*im);}
 
    Komplex operator *= (const Komplex & k) {
       Komplex t;
       t.re=(k.re*re)-(k.im*im);
       t.im=(k.re*im)+(re*k.im);
       return *this = t;
    }
    void Kiir() const { cout << re << "+" << im << "i"; }
  private:
    double re, im;
  friend Komplex operator*(const Komplex&, const Komplex&);
};
 
Komplex operator*(const Komplex& k1, const Komplex& k2) {
   Komplex k=k1;
   k*= k2;
   return k;
}
 
int main() {
   Komplex k1(7), k2(3,4), k3(k2);
   cout << double(k3)<< endl;           // a kiírt érték:  5
   cout <<double(Komplex(10))<< endl;   // a kiírt érték: 10
   Komplex x(2,-1), y(3,4);
   x*=y;
   x.Kiir();                            // 10+5i
}

Felhívjuk a figyelmet, hogy a Komplex osztály három konstruktora egyetlen konstruktorral helyettesíthető, amelyben alapértelmezett argumentumokat használunk:

        Komplex(double a=0, double b=0) : re(a), im(b) {}

A C++ nyelv lehetővé teszi, hogy az osztályokon alapuló I/O adatfolyamoknak „megtanítsuk” a saját készítésű osztályok objektumainak kezelését. Az adatfolyam osztályok közül az istream az adatbevitelért, míg az ostream az adatkivitelért felelős.

Az input/output műveletek végzéséhez a >> és a << operátorok túlterhelt változatait használjuk. A szükséges működés eléréséhez friend operátorfüggvényként kell elkészítenünk a fenti műveletek saját változatait, mint ahogy ez a Komplex osztály bővített változatában látható:

#include <cmath>
#include <sstream>
#include <iostream>
using namespace std;
 
class Komplex {
  public:
    Komplex(double a=0, double b=0) : re(a), im(b) {}
    operator double() {return sqrt(re*re+im*im);}
 
    Komplex operator *= (const Komplex & k) {
       Komplex t;
       t.re=(k.re*re)-(k.im*im);
       t.im=(k.re*im)+(re*k.im);
       return *this = t;
    }
  private:
    double re, im;
  friend Komplex operator*(const Komplex&, const Komplex&);
  friend istream & operator>>(istream &, Komplex &);
  friend ostream & operator<<(ostream &, const Komplex &);
};
 
Komplex operator*(const Komplex& k1, const Komplex& k2) {
   Komplex k=k1;
   k*= k2;
   return k;
}
 
// Az adatbevitel formátuma: 12.23+7.29i, illetve 12.23-7.29i
istream & operator>>(istream & is, Komplex & c) {
   string s;
   getline(is, s);
   stringstream ss(s);
   if (!(ss>>c.re>>c.im))
      c=Komplex(0);
   return is;
 }
 
// Adatkiviteli formátum: 12.23+7.29i, illetve 12.23-7.29i
ostream & operator<<(ostream & os, const Komplex & c) {
   os<<c.re<<(c.im<0? '-' : '+')<<fabs(c.im)<<'i';
   return os;
 }
 
int main() {
   Komplex a, b;
   cout<<"Kerek egy komlex szamot: ";  cin >> a;
   cout<<"Kerek egy komlex szamot: ";  cin >> b;
   cout<<"A komplex szamok szorzata: " << a*b <<endl;
}

A származtatott osztály öröklött tagjai általában ugyanúgy érhetők el, mint a saját tagok. Ha azonban a származtatott osztályban az öröklött tag nevével azonos néven hozunk létre adattagot vagy tagfüggvényt, akkor az elfedi az ősosztály tagját. Ilyen esetekben a hatókör operátort kell használnunk a hivatkozáshoz:

        Osztálynév::tagnév

A fordítóprogram a tagneveket az osztály hatókörrel együtt azonosítja, így minden tagnév felírható a fenti formában. A III.3.1. szakasz példaprogramjában látunk példákat az elmondottakra.

class Pont3D : public Pont2D {
   protected:
      int z;
   public:
      Pont3D(int a=0, int b=0, int c=0):Pont2D(a,b),z(c) {}
      Pont3D(Pont3D & p):Pont2D(p.x, p.y),z(p.z) {}
      // …
      void Mozgat(const Pont3D& p) { 
           Pont2D::x = p.x; y = p.y; z = p.z;}
      // …
};
int main() {
  Pont2D p1(12,23), p2(p1), p3;
  Pont3D q1(7,29,80), q2(q1), q3;
  q2.Pont2D::Kiir();
  q2.Pont2D::Mozgat(1,2); // Mozgatás a x-y síkban
  q2.Pont2D::Mozgat(p1);
  // …
}

Az alábbi táblázatban összefoglaltuk, hogy az említett példaprogram osztályai, milyen (általuk elérhető) tagokkal rendelkeznek. Elfedés esetén a tagok osztálynévvel minősített változatát adtuk meg:

Az alaposztály „barátja” (friend) a származtatott osztályban csak az alaposztályból öröklött tagokat érheti el. A származtatott osztály „barátja” az alaposztályból csak a nyilvános és a védett tagokat érheti el.

A való életben az összetett objektumok gyakran kisebb, egyszerűbb objektumokból épülnek fel. Például, egy gépkocsi fémvázból, motorból, néhány abroncsból, sebességváltóból, kormányozható kerekekből és nagyszámú más részegységből állítható össze. Elvégezve az összeállítást mondhatjuk, hogy a kocsinak van egy (has-a) motorja, van egy sebességváltója stb.

A Kor példánkban a körnek van egy középpontja, amit a Pont típusú p tagobjektum tárol. Fontos megjegyeznünk, hogy a Kor osztály tagfüggvényiből csak a Pont osztály nyilvános tagjait érhetjük el.

#include "Pont.h"
 
class Kor {
  protected:
    int r;
  public:
    Pont p; // kompozció
    Kor(int x=0, int y=0, int r=0)
        : p(x, y), r(r) {}
    Kor(const Pont& p, int r=0)
        : p(p), r(r) {}
    int GetR() {return r;}
    void SetR(int a) { r = a; }
};
 
int main() {
    Kor k1(100, 200, 10);
    k1.p.Kiir();
    cout<<k1.p.GetX()<<endl;
    cout<<k1.GetR()<<endl;
}

A kompozícióhoz hasonlóan az öröklésre is számos példát találunk a való életben. Mindenki örököl géneket a szüleitől, a C++ nyelv is sok mindent örökölt a C nyelvtől, amely szintén örökölte a jellegzetességeinek egy részét az elődeitől. Származtatás során közvetlenül megkapjuk az ősobjektum(ok) attribútumait és viselkedését, és kibővítjük vagy pontosítjuk azokat.

A példánkban a Kor típusú objektum szerves részévé válik a Pont objektum, mint a kör középpontja, ami teljes mértékben megfelel a kör geometriai definíciójának. Ellentétben a kompozícióval a Kor osztály tagfüggvényiből a Pont osztály védett és nyilvános tagjait egyaránt elérhetjük.

#include "Pont.h"
 
class Kor : public Pont { // öröklés
  protected:
    int r;
  public:
    Kor(int x=0, int y=0, int r=0)
        : Pont(x, y), r(r) {}
    Kor(const Pont & p, int r=0)
        : Pont(p), r(r) {}
    int GetR() {return r;}
    void SetR(int a) { r = a; }
};
 
int main() {
    Kor k1(100, 200, 10);
    k1.Kiir();
    cout<<k1.GetX()<<endl;
    cout<<k1.GetR()<<endl;
}

Korai kötés során a fordító a statikusan befordítja a kódba a közvetlen tagfüggvény-hívásokat. Az osztályok esetén ez az alapértelmezett működési mód, ami jól látható az alábbi példaprogram futásának eredményéből.

III.8. ábra - Korai kötés példa

class Alap {
 protected:
     int ertek;
 public:
     Alap(int a=0) : ertek(a) { }
     const char* GetNev() const { return "Alap"; }
     int GetErtek() const { return ertek; }
 };
 
class Szarmaztatott: public Alap {
 protected:
     int ertek;
 public:
     Szarmaztatott(int a=0, int b=0) : Alap(a), ertek(b) { }
     const char* GetNev() const { return "Szarmaztatott"; }
     int GetErtek() const { return ertek; }
 };
 
int main() {
  Alap a;
  Szarmaztatott b(12, 23);
 
  a = b;
  Alap &rA = b;
  Alap *pA = &b;
 
  cout<<"a \t" <<  a.GetNev()<<"\t"<<  a.GetErtek()<<endl;
  cout<<"b \t" <<  b.GetNev()<<"\t"<<  b.GetErtek()<<endl;
  cout<<"rA\t" << rA.GetNev()<<"\t"<< rA.GetErtek()<<endl;
  cout<<"pA\t" <<pA->GetNev()<<"\t"<<pA->GetErtek()<<endl;
}

A programban a GetErtek() tagfüggvény hívásait a III.8. ábra szemlélteti. A program futásának eredménye:

a       Alap    12
b       Szarmaztatott   23
rA      Alap    12
pA      Alap    12

Alapvetően változik a helyzet (III.8. ábra), ha az Alap osztályban a GetNev(), GetErtek() tagfüggvényeket virtuálissá tesszük.

class Alap {
 protected:
     int ertek;
 public:
     Alap(int a=0) : ertek(a) { }
     virtual const char* GetNev() const { return "Alap"; }
     virtual int GetErtek() const { return ertek; }
 };

A példaprogram futásának eredménye is módosult:

a       Alap    12
b       Szarmaztatott   23
rA      Szarmaztatott   23
pA      Szarmaztatott   23

III.9. ábra - Késői kötés példa

A virtuális függvények hívását közvetett módon, memóriában tárolt címre történő ugrással helyezi el a kódban a fordító. A címek tárolására használt virtuális metódustábla (VMT) a program futása során osztályonként, az osztály első példányosításakor jön létre. A VMT az aktuális, újradefiniált virtuális függvények címét tartalmazza. Az osztályhierarchiában található azonos nevű virtuális függvények azonos indexszel szerepelnek ezekben a táblákban, ami lehetővé teszi a virtuális tagfüggvények teljes lecserélését.

Amennyiben egy osztály egy vagy több virtuális tagfüggvénnyel rendelkezik, a fordító kiegészíti az objektumot egy „virtuális mutatóval”, amely egy virtuális metódustáblának (VMT – Virtual Method Table) vagy virtuális függvénytáblának (VFTable – Virtual Function Table) hívott globális adattáblára mutat. A VMT függvénypointereket tartalmaz, amelyek az adott osztály, illetve az ősosztályok legutoljára újradefiniált virtuális tagfüggvényeire mutatnak (III.10. ábra). Az azonos nevű virtuális függvények címe azonos indexszel szerepel ezekben a táblákban.

III.10. ábra - A példaprogram virtuális metódustáblái

Az osztályonkénti VMT futás közben, az első konstruktorhíváskor jön létre. Ennek következtében a hívó és hívott tagfüggvény közötti kapcsolat szintén futás közben realizálódik. A fordító mindössze egy olyan hívást helyez a kódba, amely a VMT i. elemének felhasználásával megy végbe (call VMT[i]).

A könyvtár elemei öt csoportba sorolhatók:

Az sablonkezelésnek megfelelően az egyes lehetőségek fejállományok beépítésével érhetők el. Az alábbi táblázatban összefoglaltuk az STL leggyakrabban használt deklarációs fájljait:

Az STL algoritmusai valamint az adatfolyam iterátorai egydimenziós C++ tömbök esetén is használhatók. Ezt az teszi lehetővé, hogy a C++ mutatókhoz és az iterátorokhoz ugyanazokat a műveleteket használhatjuk: a mutatott adat (*), léptetés (++) stb. Továbbá, az algoritmus függvénysablonok többsége az adatsor kezdetét (begin) és az utolsó adat utáni pozícióját (end) kijelölő általánosított mutatókat vár argumentumként.

Az alábbi példában egy hételemű egész tömb elemein különböző műveleteket hajtunk végre az STL algoritmusainak segítségével. A bemutatottak alapján a több mint 60 algoritmus többségét eredményesen használhatjuk a hagyományos C++ programjainkban is.

#include <iostream>
#include <iterator>
#include <algorithm>
using namespace std;
 
void Kiir(const int x[], int n) {
    static ostream_iterator<int> out(cout,"\t");
    cout<< "\t";
    copy(x, x+n, out);
    cout<<endl;
}
 
void IntKiir(int a) {
    cout << "\t" << a << endl;
}
 
int main() {
    const int db = 7;
    int adat[db]={2, 7, 10, 12, 23, 29, 80};
 
    cout << "Eredeti tömb: " << endl;
    Kiir(adat, db);
 
    cout << "Következő permutació: " << endl;
    next_permutation(adat,adat+db);
    Kiir(adat, db);
 
    cout << "Sorrend megfordítása: " << endl;
    reverse(adat,adat+db);
    Kiir(adat, db);
 
    cout << "Véletlen keverés: " << endl;
    for (int i=0; i<db; i++) {
       random_shuffle(adat,adat+db);
       Kiir(adat, db);
    }
 
    cout << "A legnagyobb elem: ";
    cout << *max_element(adat,adat+db) << endl;
 
    cout << "Elem keresése:";
    int *p=find(adat,adat+db, 7);
    if (p != adat+db)
      cout << "\ttalált" <<endl;
     else
      cout << "\tnem talált" <<endl;
 
    cout << "Rendezés: " << endl;
    sort(adat,adat+db);
    Kiir(adat, db);
 
    cout << "Elemek kiírása egymás alá:"<< endl;
    for_each(adat, adat+db, IntKiir);
    Kiir(adat, db);
 
    cout << "Csere: " << endl;
    swap(adat[2],adat[4]);
    Kiir(adat, db);
 
    cout << "Feltöltés: " << endl;
    fill(adat,adat+db, 123);
    Kiir(adat, db);
}

Ugyancsak beszédes a program futásának eredménye:

Eredeti tömb:
        2       7       10      12      23      29      80
Következő permutáció:
        2       7       10      12      23      80      29
Sorrend megfordítása:
        29      80      23      12      10      7       2
Véletlen keverés:
        10      80      2       23      29      7       12
        2       10      23      80      29      12      7
        7       12      2       10      80      29      23
        2       12      29      10      80      7       23
        12      23      7       29      10      2       80
        7       23      12      2       80      10      29
        7       12      23      2       29      10      80
A legnagyobb elem: 80
Elem keresése:  talált
Rendezés:
        2       7       10      12      23      29      80
Elemek kiírása egymás alá:
        2
        7
        10
        12
        23
        29
        80
        2       7       10      12      23      29      80
Csere:
        2       7       23      12      10      29      80
Feltöltes:
        123     123     123     123     123     123     123

A konténereket két fő csoportba sorolhatjuk: adatsorok (soros) és asszociatív tárolók. A soros tárolókra (vektor - vector, lista - list, kettősvégű sor - deque) jellemző, hogy elemek sorrendjét a programozó határozza meg. Az asszociatív tárolók (leképzés - map, halmaz – set, bithalmaz - bitset stb.) közös tulajdonsága, hogy az elemek sorrendét maga a konténer szabja meg, valamint az elemek egy kulcs alapján érhetők el. Mindegyik tároló dinamikusan kezeli a memóriát, tehát az adatok száma szabadon változtatható.

A tároló objektumok tagfüggvényei segítik az adatok kezelését és elérését. Mivel ez a függvénykészlet függ a konténer típusától, felhasználás előtt mindenképpen a szakirodalomban (Interneten) kell megnézni, hogy egy adott taroló esetén mik a lehetőségeink. Most csak néhány általános művelet áttekintésére vállalkozunk:

A következőkben egy vector tárolót használó programmal szemléltetjük az elmondottakat:

#include <vector>
#include <algorithm>
#include <iterator>
#include <iostream>
using namespace std;
 
double Osszeg(const vector<double>& dv) {
   vector<double>::const_iterator p; // konstans iterátor
   double s = 0;
   for (p = dv.begin(); p != dv.end(); p++)
      s += *p;
   return s;
}
 
bool Paratlan (int n) {
    return (n % 2) == 1;
}
 
int main() {
   // kimeneti iterátor
   ostream_iterator<double>out(cout, " ");
   double adatok[]  = {1.2, 2.3, 3.4, 4.5, 5.6};
 
   // A vektor létrehozása az adatok tömb elemivel
   vector<double> v(adatok, adatok+5);
 
   // A vektor kiírása
   copy(v.begin(), v.end(), out);  cout << endl;
   cout<<"Elemösszeg: "<<Osszeg(v)<<endl;
 
   // A vektor bővítése elemekkel
   for (int i=1; i<=5; i++)
       v.push_back(i-i/10.0);
   copy(v.begin(), v.end(), out);  cout << endl;
 
   // Minden elem növelése 4.5 értékkel
   for (int i=0; i<v.size(); i++)
       v[i] += 4.5;
   copy(v.begin(), v.end(), out);  cout << endl;
 
   // Minden elem egésszé alakítása
   vector<double>::iterator p;
   for (p=v.begin(); p!=v.end(); p++)
      *p = int(*p);
   copy(v.begin(), v.end(), out);  cout << endl;
 
   // Minden második elem törlése
   int index = v.size()-1;
   for (p=v.end(); p!=v.begin(); p--)
      if (index-- % 2 ==0)
         v.erase(p);
   copy(v.begin(), v.end(), out);  cout << endl;
 
   // A vektor elemeinek rendezése
   sort(v.begin(), v.end() );
   copy(v.begin(), v.end(), out);  cout << endl;
 
   // 7 keresése a vektorban
   p = find(v.begin(), v.end(), 7);
   if (p != v.end() )
       cout << "talált"<< endl;
   else
       cout << "nem talált"<< endl;
 
   // A páratlan elemek száma
   cout<< count_if(v.begin(), v.end(), Paratlan)<< endl;
}

A program futásának eredménye:

1.2 2.3 3.4 4.5 5.6
Elemösszeg: 17
1.2 2.3 3.4 4.5 5.6 0.9 1.8 2.7 3.6 4.5
5.7 6.8 7.9 9 10.1 5.4 6.3 7.2 8.1 9
5 6 7 9 10 5 6 7 8 9
5 7 10 6 8
5 6 7 8 10
talált
2

A konténer-adaptációk olyan tárolók, amelyek módosítják a fenti tároló osztályokat az alapműködéstől eltérő viselkedés biztosítása érdekében. A támogatott adaptációk a verem (stack), a sor (queue) és a prioritásos sor (priority_queue).

Az adaptációk viszonylag kevés tagfüggvénnyel rendelkeznek, és mögöttük különböző tárolók állhatnak. Példaként tekintsük a stack osztálysablont!

A „last-in, first-out” működésű verem egyaránt adaptálható a vector, a list és a deque tárolókból. Az adaptált stack-függvényeket táblázatban foglaltuk össze:

Az alábbi példaprogramban adott számrendszerbe való átváltásra használjuk a vermet:

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
 
int main() {
   int szam=2013, alap=16;
   stack<int, vector<int> > iverem;
 
   do {
     iverem.push(szam % alap);
     szam /= alap;
   } while (szam>0);
 
   while (!iverem.empty()) {
      szam = iverem.top();
      iverem.pop();
      cout<<(szam<10 ? char(szam+'0'): char(szam+'A'-10));
   }
}