object-oriented programming (tsz. object-oriented programmings)
Az objektum-orientált programozás (OOP) egy programozási paradigma, amely a problémák megoldásához az objektumokat és azok kölcsönhatásait használja. A C++ nyelv egyik alapvető jellemzője, hogy erőteljesen támogatja az OOP elveit, mint például az öröklődés, polimorfizmus, encapsuláció és abstrakció.
Az osztály egy sablon, amely meghatározza az objektumok tulajdonságait (adatokat) és viselkedését (módszereket). Az objektum az osztály egy példánya, amely tartalmazza a tényleges adatokat.
#include <iostream>
using namespace std;
// Osztály definíció
class Auto {
public:
string marka;
int evjarat;
// Konstruktor
Auto(string m, int ev) : marka(m), evjarat(ev) {}
// Metódus
void bemutat() {
cout << "A " << evjarat << "-es " << marka << " autó." << endl;
}
};
int main() {
// Objektum létrehozása
Auto auto1("Toyota", 2020);
// Metódus meghívása
auto1.bemutat();
return 0;
}
A kimenet:
A 2020-es Toyota autó.
Ebben a példában az Auto osztály rendelkezik két adattaggal (marka, evjarat) és egy metódussal (bemutat), amely kiírja az autó adatait.
Az encapsuláció az OOP egyik alapelve, amely biztosítja, hogy az osztály adattagjai (változók) és metódusai (funkciók) védve legyenek, és csak az osztály nyilvános metódusain keresztül érhetők el. Ez segít megakadályozni az adatok közvetlen módosítását, és biztosítja az objektumok integritását.
#include <iostream>
using namespace std;
class BankSzamla {
private:
double egyenleg; // Privát adat
public:
// Konstruktor
BankSzamla(double egyenleg) : egyenleg(egyenleg) {}
// Nyilvános metódusok a privát adat elérésére
void befizet(double osszeg) {
if (osszeg > 0) {
egyenleg += osszeg;
cout << "Befizetve: " << osszeg << " Ft" << endl;
}
}
void kivesz(double osszeg) {
if (osszeg <= egyenleg) {
egyenleg -= osszeg;
cout << "Kivett: " << osszeg << " Ft" << endl;
} else {
cout << "Nem elegendő egyenleg!" << endl;
}
}
void megjelenit() {
cout << "A szamla egyenlege: " << egyenleg << " Ft" << endl;
}
};
int main() {
// Objektum létrehozása
BankSzamla szamla(1000);
// Metódusok hívása
szamla.megjelenit();
szamla.befizet(500);
szamla.kivesz(200);
szamla.megjelenit();
return 0;
}
A kimenet:
A szamla egyenlege: 1000 Ft Befizetve: 500 Ft Kivett: 200 Ft A szamla egyenlege: 1300 Ft
Ebben az esetben az egyenleg adat privát, így közvetlenül nem érhető el kívülről. A felhasználó csak a nyilvános metódusokon keresztül tud változtatni rajta, ami biztonságosabbá teszi a programot.
Az öröklődés lehetővé teszi, hogy egy osztály (származtatott osztály) örökölje egy másik osztály (alaposztály) tulajdonságait és metódusait. Az öröklődés segít elkerülni a kód ismétlését, és lehetővé teszi a kód újrafelhasználását.
#include <iostream>
using namespace std;
// Alaposztály
class Allat {
public:
string nev;
// Konstruktor
Allat(string n) : nev(n) {}
// Metódus
void hangotAd() {
cout << nev << " hangot ad." << endl;
}
};
// Származtatott osztály
class Kutya : public Allat {
public:
Kutya(string n) : Allat(n) {}
// Metódus felülírása
void hangotAd() {
cout << nev << " ugat." << endl;
}
};
int main() {
Allat allat("Állat");
Kutya kutya("Rex");
allat.hangotAd();
kutya.hangotAd();
return 0;
}
A kimenet:
Állat hangot ad. Rex ugat.
Itt a Kutya osztály örökli az Allat osztályt, és felülírja a hangotAd metódust. Az Allat osztály metódusa általános, míg a Kutya osztályban az adott kutyára vonatkozó specifikus viselkedést valósítjuk meg.
A polimorfizmus azt jelenti, hogy ugyanaz a metódus vagy függvény különböző osztályokban eltérően viselkedhet. Ez lehetővé teszi, hogy egy típusú objektumot különböző származtatott osztályokkal is kezeljünk, miközben minden osztály saját viselkedését alkalmazza.
#include <iostream>
using namespace std;
// Alaposztály
class Forma {
public:
virtual void rajzol() {
cout << "Alapforma rajzolása." << endl;
}
};
// Származtatott osztály
class Kor : public Forma {
public:
void rajzol() override {
cout << "Kör rajzolása." << endl;
}
};
class Teglalap : public Forma {
public:
void rajzol() override {
cout << "Téglalap rajzolása." << endl;
}
};
int main() {
Forma* forma1 = new Kor();
Forma* forma2 = new Teglalap();
forma1->rajzol(); // Polimorfizmus
forma2->rajzol(); // Polimorfizmus
delete forma1;
delete forma2;
return 0;
}
A kimenet:
Kör rajzolása. Téglalap rajzolása.
A fenti példában a Forma osztály egy virtuális rajzol metódust tartalmaz, amelyet a Kor és a Teglalap osztályok felülírnak. A polimorfizmus lehetővé teszi, hogy a program a Forma típusú mutatókat használva hívja meg a megfelelő rajzol metódust, még akkor is, ha a valós típusuk Kor vagy Teglalap.
Az abstrakció az OOP egy másik alapelve, amely lehetővé teszi, hogy elrejtsük a részleteket, és csak a fontos információkat jelenítsük meg. Absztrakt osztályok használatával valósíthatjuk meg, amelyek nem példányosíthatók, csak származtatott osztályok örökölhetik őket.
#include <iostream>
using namespace std;
// Absztrakt osztály
class Forma {
public:
virtual void rajzol() = 0; // Tiszta virtuális függvény
};
class Kor : public Forma {
public:
void rajzol() override {
cout << "Kör rajzolása." << endl;
}
};
int main() {
// Forma forma; // Hiba! Nem példányosítható absztrakt osztály
Kor kor;
kor.rajzol();
return 0;
}
A kimenet:
Kör rajzolása.
A tiszta virtuális függvény (= 0) az absztrakt osztályokban használható, amelyek lehetővé teszik, hogy a származtatott osztályokban valósítsuk meg a funkcionalitást. Az absztrakt osztály nem példányosítható közvetlenül.
Az objektum-orientált programozás (OOP) lehetővé teszi, hogy a programokat objektumok segítségével tervezzük meg, amelyek az osztályok példányai, és amelyek adatokat és viselkedéseket egyaránt tartalmaznak. A C++ nyelv erőteljesen támogatja az OOP alapelveit, mint az öröklődés, polimorfizmus, encapsuláció és abstrakció. A példák segítenek megérteni az OOP fogalmát és annak alkalmazását a C++ nyelvben.