C++ operator overloading

Angol

Főnév

C++ operator overloading (tsz. C++ operator overloadings)

(informatika) Az operátor túlterhelés (operátorok átdefiniálása/operator overloading) lehetővé teszi, hogy a C++ beépített operátorait (+, -, *, /, ==, [], stb.) saját osztályainkhoz igazítsuk. Ezáltal objektumok között is végezhetünk műveleteket ugyanúgy, mint az alapvető típusoknál.

1. Mi az operátor túlterhelés?

C++-ban az operátorok alapértelmezett működése adott az alaptípusokra (pl. int a = 5 + 3;). Az operátor túlterheléssel ezt a működést saját osztályainkra is kiterjeszthetjük.

Példa:

Egy vektorokkal dolgozó osztály esetén így tehetjük lehetővé az összeadást + operátorral:

#include <iostream>
using namespace std;

class Vektor {
public:
    int x, y;

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

    // Operátor túlterhelés a `+` operátorra
    Vektor operator+(const Vektor& masik) {
        return Vektor(x + masik.x, y + masik.y);
    }

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

int main() {
    Vektor v1(2, 3);
    Vektor v2(4, 5);
    Vektor eredmeny = v1 + v2;  // `+` operátor használata

    eredmeny.kiir();  // Kiírja: (6, 8)
    return 0;
}

2. Hogyan működik az operátor túlterhelés?

Az operátor túlterhelés egy speciális tagfüggvény vagy globális függvény, amely újradefiniálja egy operátor működését az osztályhoz.

Szintaxis:

VisszatérésiTípus operatorOperátor(const Osztálynév& másik) {
    // Új művelet
}

3. Unáris operátorok túlterhelése

Az unáris operátorok (pl. -, ++, --, !) egyetlen operandusra hatnak.

Példa: - operátor túlterhelése egy vektor osztályban:

class Vektor {
public:
    int x, y;

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

    // Negáció (-) operátor túlterhelése
    Vektor operator-() {
        return Vektor(-x, -y);
    }

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

int main() {
    Vektor v1(3, -7);
    Vektor v2 = -v1; // Negálás

    v2.kiir();  // Kiírja: (-3, 7)
    return 0;
}

4. Bináris operátorok túlterhelése

A bináris operátorok két operandust igényelnek (pl. +, -, *, /, ==).

**Példa: `*` operátor túlterhelése skalárszorzásra**

class Vektor {
public:
    int x, y;

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

    // Skalárszorzás (vektor * szám)
    Vektor operator*(int skalár) {
        return Vektor(x * skalár, y * skalár);
    }

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

int main() {
    Vektor v1(2, 3);
    Vektor v2 = v1 * 3; // Skalárszorzás

    v2.kiir(); // Kiírja: (6, 9)
    return 0;
}

5. Összehasonlító operátorok túlterhelése

Az összehasonlító operátorok (==, !=, <, >, <=, >=) túlterhelése akkor hasznos, ha két objektumot akarunk közvetlenül összehasonlítani.

Példa: `==` operátor túlterhelése

class Pont {
public:
    int x, y;

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

    // Egyenlőségvizsgálat (==) operátor túlterhelése
    bool operator==(const Pont& masik) {
        return (x == masik.x && y == masik.y);
    }
};

int main() {
    Pont p1(5, 10);
    Pont p2(5, 10);
    Pont p3(3, 4);

    cout << (p1 == p2) << endl; // Kiírja: 1 (true)
    cout << (p1 == p3) << endl; // Kiírja: 0 (false)
    return 0;
}

6. Indexelő `[]` operátor túlterhelése

A [] operátor lehetővé teszi egyedi indexelési logikák implementálását.

Példa: saját dinamikus tömb osztály

class Tomb {
private:
    int elemek[5];

public:
    Tomb() { for (int i = 0; i < 5; i++) elemek[i] = i * 10; }

    // Indexelési operátor túlterhelése
    int operator[](int index) {
        if (index < 0 || index >= 5) {
            cout << "Hibas index!" << endl;
            return -1;
        }
        return elemek[index];
    }
};

int main() {
    Tomb t;
    cout << t[2] << endl;  // Kiírja: 20
    cout << t[10] << endl; // Kiírja: Hibas index! -1
}

7. Beillesztési (`<<`) és kiolvasási (`>>`) operátor túlterhelése

A cout << obj és cin >> obj használatához a << és >> operátort túl kell terhelni.

Példa: `<<` operátor túlterhelése

#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 (cout << obj)
    friend ostream& operator<<(ostream& os, const Pont& p) {
        os << "(" << p.x << ", " << p.y << ")";
        return os;
    }
};

int main() {
    Pont p1(3, 4);
    cout << "A pont koordinátái: " << p1 << endl; // Kiírja: (3, 4)
    return 0;
}

Magyarázat: - A << operátort friend függvényként definiáljuk, mert a cout az ostream osztály része.

8. Mikor használjunk operátor túlterhelést?

✔ Ha az osztályunk objektumait szeretnénk intuitívan kezelni (pl. matematikai műveletek).
✔ Ha egyedi összehasonlítást vagy indexelést akarunk megvalósítani.
✔ Ha cout-tal és cin-nel akarunk objektumokat kiírni vagy beolvasni.

Összegzés

Az operátor túlterhelés lehetővé teszi, hogy az alapvető operátorokat saját osztályainkra alkalmazzuk.
Unáris (-, ++, --) és bináris (+, -, *, /, ==, [], <<) operátorok is túlterhelhetők.
A túlterhelés növeli az olvashatóságot és egyszerűsíti az osztályok használatát.

További információk

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