conversion operator

Angol

Főnév

conversion operator (tsz. conversion operators)

(informatika) A conversion operator (típuskonverziós operátor) C++-ban lehetővé teszi, hogy egy objektumot automatikusan vagy kifejezetten (explicit módon) más típusra alakítsunk, mintha az adott típus lenne. Ez egy speciális operátor, amelyet operator T() szintaxissal írunk, ahol T a céltípus.

🧠 Mi az a conversion operator?

Olyan tagfüggvény, ami nem kap paramétert, de egy másik típusra alakítja át az objektumot, például:

class MyClass {
public:
    operator int() const {
        return 42;
    }
};

Ez lehetővé teszi:

MyClass obj;
int x = obj;  // implicit konverzió működik

📦 Alapszintaxis

class ClassName {
public:
    operator TargetType() const;  // konverzió TargetType típusra
};

Nem lehetnek paraméterei
Nem lehet visszatérési típust megadni → operator T() maga a típus
Lehet const vagy explicit

📘 Példa: implicit konverzió

class Szam {
    int ertek;
public:
    Szam(int e): ertek(e) {}

    operator int() const {
        return ertek;
    }
};

Szam s(5);
int x = s;     // működik, s átalakul int-té
std::cout << x;  // 5

🔐 `explicit` conversion operator (C++11-től)

class Szam {
    int ertek;
public:
    Szam(int e): ertek(e) {}

    explicit operator int() const {
        return ertek;
    }
};

Szam s(5);
// int x = s;          // ❌ hibás: implicit konverzió letiltva
int x = static_cast<int>(s);  // ✅ működik

🔁 Gyakori használat

Használat	Példa
Objektum konvertálása számra	`operator int()`
Objektum stringgé alakítása	`operator std::string()`
Logikai értékké alakítás	`explicit operator bool()`
STL kompatibilitás	`operator const char*()`

🧩 Példa: `operator std::string`

class User {
    std::string nev;
public:
    User(std::string n): nev(n) {}

    operator std::string() const {
        return "User: " + nev;
    }
};

User u("Anna");
std::string s = u;  // implicit stringgé alakul
std::cout << s;     // "User: Anna"

⚠️ Miért lehet veszélyes?

Implicit konverzió miatt hibás összehasonlítás vagy túlterhelt függvényválasztás:

if (user == "admin") { ... }  // akkor is igaz lehet, ha csak a string konverzió miatt

Több konverziós útvonal → ambiguitás:
```
operator int();
operator double();
```
Egy f(x) hívásnál nem egyértelmű, hogy melyikre konvertáljon.

🔧 Best practice

Szabály	Miért
Használj `explicit`-et	Megelőzi a nem kívánt automatikus konverziót
Csak indokolt esetben	Ne legyen túl sok konverzió – nehéz követni
Lehetőség szerint `const`	Ne módosítsa az objektum állapotát

✅ Összegzés

Tulajdonság	Részletek
Függvény neve	`operator T()`
Paraméter	nincs
Célja	Más típusra alakítás (pl. `int`, `std::string`)
Alapértelmezett	Lehet implicit vagy `explicit` (C++11+)
Veszélyei	Nem várt konverzió, típusütközés
Javaslat	Használj `explicit`-et, ha nem akarsz automatikus konverziót

További információk

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