encapsulation

encapsulation (tsz. encapsulations)

1. (informatika) Az egységbezárás az objektumorientált programozás (OOP) egyik alapelve, amely biztosítja az adatok és a hozzájuk kapcsolódó műveletek védelmét és megfelelő hozzáférését. A C++ programozási nyelvben az enkapszulációt osztályok segítségével valósítjuk meg. Az alábbiakban részletesen bemutatjuk az enkapszulációt, annak előnyeit, megvalósítását, valamint gyakorlati példákat is adunk.

Az enkapszuláció célja, hogy egy osztályon belül elrejtsük az adatok belső állapotát, és csak megfelelően definiált interfészeken (metódusokon) keresztül engedjük meg azok elérését vagy módosítását. Ez azt jelenti, hogy a privát változókat nem lehet közvetlenül kívülről módosítani, csak meghatározott függvények (getterek és setterek) használatával.

Az enkapszuláció előnyei:

1. Adatvédelem és adatbiztonság
   • A privát változók védelmet nyújtanak a külső beavatkozás ellen.
   • Csak az osztályon belüli meghatározott metódusokon keresztül lehet az adatokhoz hozzáférni.
2. Modularitás és könnyebb karbantarthatóság
   • Ha az osztály interfésze változatlan marad, a belső implementációt könnyen módosíthatjuk anélkül, hogy a program többi részét érintenénk.
3. Kód újrafelhasználhatóság
   • Az enkapszulációval jól definiált és újrafelhasználható osztályokat készíthetünk.
4. Hibakeresés megkönnyítése
   • Az osztály belső állapotának változásai könnyebben nyomon követhetők és kontrollálhatók.

C++-ban az enkapszulációt három hozzáférési szinttel valósítjuk meg:

1. private: Az osztálytagok csak az osztályon belül érhetők el.
2. protected: Az osztálytagok az osztályon belül és az örökölt osztályokban is elérhetők.
3. public: Az osztálytagok kívülről is elérhetők.

#include <iostream>
using namespace std;

class Auto {
private:
    string marka;
    int sebesseg;

public:
    // Konstruktor
    Auto(string m, int s) {
        marka = m;
        sebesseg = s;
    }

    // Getter a márkához
    string getMarka() {
        return marka;
    }

    // Getter a sebességhez
    int getSebesseg() {
        return sebesseg;
    }

    // Setter a sebességhez
    void setSebesseg(int ujSebesseg) {
        if (ujSebesseg >= 0) {
            sebesseg = ujSebesseg;
        } else {
            cout << "Hibás sebességérték!" << endl;
        }
    }
};

int main() {
    Auto a("Ford", 120);

    cout << "Autó márkája: " << a.getMarka() << endl;
    cout << "Sebesség: " << a.getSebesseg() << " km/h" << endl;

    // Módosítás setterrel
    a.setSebesseg(140);
    cout << "Új sebesség: " << a.getSebesseg() << " km/h" << endl;

    return 0;
}

Autó márkája: Ford
Sebesség: 120 km/h
Új sebesség: 140 km/h

Ebben a példában az Auto osztály privát változókkal dolgozik, amelyeket csak a getter és setter metódusok segítségével érhetünk el.

A getterek és setterek az osztályon belüli adatokhoz való hozzáférést biztosítják.

• Getterek: Az adatok lekérésére szolgálnak, de nem módosítják azokat.
• Setterek: Lehetővé teszik az adatok módosítását, de csak ellenőrzött módon.

A setter függvényekbe beépíthetünk adatellenőrzést, például megakadályozhatjuk a negatív értékeket egy sebességnél.

Az információ elrejtése (data hiding) az enkapszuláció egyik fontos aspektusa. Lényege, hogy az adatok közvetlen módosítása tiltott, így a program stabilabb és biztonságosabb lesz.

Példa egy helytelen megoldásra, ahol az osztály változói nyilvánosak:

class HibasAuto {
public:
    string marka;
    int sebesseg;
};

int main() {
    HibasAuto a;
    a.marka = "Toyota";
    a.sebesseg = -100; // Hibás érték!
    return 0;
}

Ebben az esetben a sebesseg értéke lehet negatív, ami logikai hibát okozhat a programban.

Ha egy getter nem módosítja az osztály adatait, akkor const kulcsszóval jelezhetjük ezt:

string getMarka() const {
    return marka;
}

Ha egy változó értékét kívülről nem akarjuk módosítani, akkor elhagyhatjuk a settert.

A friend kulcsszó lehetővé teszi, hogy egy külső függvény vagy másik osztály hozzáférjen a privát tagokhoz.

Példa:

class Bar {
private:
    int x;

public:
    Bar(int a) : x(a) {}

    friend void mutasdAzX(const Bar& b);
};

void mutasdAzX(const Bar& b) {
    cout << "Az x értéke: " << b.x << endl;
}

int main() {
    Bar b(10);
    mutasdAzX(b);
    return 0;
}

• Banki rendszerek: Az ügyfél adatai privát változókkal védettek.
• Játékokban: A karakterek életpontjai, erőforrásai védettek.
• IoT eszközök: Szenzoradatok védelme és ellenőrzött módosítása.

Az enkapszuláció egy kulcsfontosságú OOP fogalom, amely biztosítja az adatok védelmét és a programok stabilitását. C++-ban privát változókat és publikus getter/setter függvényeket használunk az adatok biztonságos kezelésére. Az enkapszuláció segítségével könnyebben karbantartható és moduláris programokat készíthetünk.

• encapsulation - Szótár.net (en-hu)
• encapsulation - Sztaki (en-hu)
• encapsulation - Merriam–Webster
• encapsulation - Cambridge
• encapsulation - WordNet
• encapsulation - Яндекс (en-ru)
• encapsulation - Google (en-hu)
• encapsulation - Wikidata
• encapsulation - Wikipédia (angol)