conversion operator overloading (tsz. conversion operator overloadings)
operator T() típusú függvényt, amely lehetővé teszi, hogy az adott objektum automatikusan vagy kifejezetten konvertálódjon egy másik típusra – például int, double, std::string, vagy akár más osztály.
A konverziós operátor nem kap paramétert, és nem adunk meg számára visszatérési típust – maga a függvény neve jelöli a céltípust:
class MyClass {
public:
operator int() const {
return 42;
}
};
Ezután használható így:
MyClass obj;
int x = obj; // automatikus (implicit) konverzió
class TypeName {
public:
operator TargetType() const;
};
const vagy explicit
operator int()class Szam {
int value;
public:
Szam(int v): value(v) {}
operator int() const {
return value;
}
};
Szam s(7);
int x = s; // implicit konverzió
std::cout << x; // 7
explicit konverzió (C++11+)class Szam {
int value;
public:
Szam(int v): value(v) {}
explicit operator int() const {
return value;
}
};
Szam s(7);
// int x = s; // ❌ nem engedélyezett
int x = static_cast<int>(s); // ✅ működik
Az explicit kulcsszó letiltja az automatikus konverziót, de megengedi a static_cast-ot.
operator std::string()class User {
std::string name;
public:
User(const std::string& n): name(n) {}
operator std::string() const {
return "User: " + name;
}
};
User u("Anna");
std::string s = u; // implicit konverzió std::stringgé
std::cout << s; // User: Anna
operator bool() – logikai kontextusbanclass Kapcsolo {
bool beKapcsolva;
public:
Kapcsolo(bool allapot): beKapcsolva(allapot) {}
explicit operator bool() const {
return beKapcsolva;
}
};
Kapcsolo k(true);
if (k) {
std::cout << "Bekapcsolva\n";
}
Az explicit operator bool() megakadályozza, hogy if (k + 1) típusú hibás használat fordítási hibákhoz vezessen.
Rational → doubleclass Rational {
int num, den;
public:
Rational(int n, int d): num(n), den(d) {}
operator double() const {
return static_cast<double>(num) / den;
}
};
Rational r(3, 4);
double d = r; // implicit konverzió
| Veszély | Magyarázat |
|---|---|
| Implicit konverzió hibák | Nem várt konverziók operator int() vagy operator double() esetén
|
| Több konverzió elérhető | Ambiguitás (operator int(), operator double() egyszerre)
|
Használj explicit-et
|
A modern C++ (11+) ezt ajánlja az átláthatóság érdekében |
| Fogalom | Leírás |
|---|---|
| Conversion operator | Függvény, amely típuskonverziót tesz lehetővé |
| Szintaxis | operator T() – nincs paraméter, nincs return típus
|
| Implicit / Explicit | explicit megakadályozza az automatikus konverziót
|
| Használat | int, double, std::string, bool, stb.
|
| Javaslat | Csak szükséges konverziókat engedélyezz, legyenek explicit-ek
|