Ugrás a tartalomhoz

ad hoc polymorphism

A Wikiszótárból, a nyitott szótárból


Főnév

ad hoc polymorphism (tsz. ad hoc polymorphisms)

  1. (informatika)

Ad hoc polimorfizmus C++-ban

1. Bevezetés

Az ad hoc polimorfizmus egy olyan polimorfizmus típus, amely lehetővé teszi, hogy ugyanazt a műveletet különböző típusokon alkalmazzuk eltérő módon. C++-ban az ad hoc polimorfizmus két fő formában jelenik meg:

  1. Funkció túlterhelés (Function Overloading)
  2. Operátor túlterhelés (Operator Overloading)

Az ad hoc polimorfizmus nem az öröklésen alapul, hanem azon, hogy ugyanazzal a névvel több különböző implementációt tudunk létrehozni, amelyek különböző típusú paramétereket fogadnak el.


2. Funkció túlterhelés (Function Overloading)

A funkció túlterhelés azt jelenti, hogy ugyanazzal a névvel több függvényt is létrehozhatunk, amelyek eltérő típusú vagy számú paramétert fogadnak el.

Példa: Funkció túlterhelés

#include <iostream>
using namespace std;

// Ugyanaz a függvénynév, de különböző paraméterlisták
void kiir(int a) {
    cout << "Egész szám: " << a << endl;
}

void kiir(double a) {
    cout << "Lebegőpontos szám: " << a << endl;
}

void kiir(string szoveg) {
    cout << "Szöveg: " << szoveg << endl;
}

int main() {
    kiir(10);
    kiir(3.14);
    kiir("Hello, világ!");
    return 0;
}

Kimenet:

Egész szám: 10
Lebegőpontos szám: 3.14
Szöveg: Hello, világ!

Fontos szabályok funkció túlterhelésnél: - A függvények azonos nevűek kell legyenek. - A paraméterlista különböznie kell (más típusú vagy eltérő számú paraméter). - A visszatérési érték nem elég a megkülönböztetéshez.

Hibás példák:

int osszeg(int a, int b);
double osszeg(int a, int b);  // HIBA! Csak a visszatérési érték különbözik!

3. Operátor túlterhelés (Operator Overloading)

C++-ban az operátorokat túl lehet terhelni, hogy egyedi működést biztosítsanak saját osztályaink számára.

Példa: + operátor túlterhelése egy Pont osztályhoz

#include <iostream>
using namespace std;

class Pont {
public:
    int x, y;

    Pont(int a, int b) : x(a), y(b) {}

    // Operátor túlterhelése
    Pont operator+(const Pont& masik) {
        return Pont(x + masik.x, y + masik.y);
    }

    void kiir() {
        cout << "Pont(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Pont p1(2, 3), p2(4, 5);
    Pont eredmeny = p1 + p2;  // Operátor túlterhelés működik!
    eredmeny.kiir();
    return 0;
}

Kimenet:

Pont(6, 8)

Fontos megjegyzések operátor túlterhelésnél: - Az operátorokat csak osztályokhoz lehet túlterhelni. - Nem minden operátor túlterhelhető (pl. . és :: nem túlterhelhetők). - Az operator+, operator-, operator==, stb. függvényeket az adott osztályban kell definiálni.


4. Ad hoc polimorfizmus vs. más polimorfizmus típusok

Polimorfizmus típusa Leírás Példa
Ad hoc polimorfizmus Azonos nevű függvények, de eltérő paraméterek vagy operátorok túlterhelése Funkció és operátor túlterhelés
Szubtípus polimorfizmus (klasszikus OOP) Egy leszármazott osztály használható az ősosztály helyett Virtuális függvények és override
Paraméteres polimorfizmus Típusfüggetlen kód sablonokkal Template függvények és osztályok


5. Összegzés

  • Az ad hoc polimorfizmus C++-ban lehetővé teszi, hogy ugyanazt a műveletet különböző típusokra alkalmazzuk eltérő módon.
  • Funkció túlterhelés (function overloading): ugyanaz a függvénynév különböző paraméterekkel.
  • Operátor túlterhelés (operator overloading): egyedi működést biztosíthatunk saját osztályainkhoz.
  • Az ad hoc polimorfizmus NEM az öröklésen alapul, hanem a fordító a megfelelő függvényt választja ki a paraméterek típusa alapján (fordítási időben történő polimorfizmus).
A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=ad_hoc_polymorphism&oldid=3499693”