explicit type conversion

Angol

Főnév

explicit type conversion (tsz. explicit type conversions)

(informatika) Az explicit type conversion (explicit típuskonverzió) C++-ban azt jelenti, hogy a programozó szándékosan alakít át egy értéket egyik típusból a másikba, egyértelműen megmondva a fordítónak, milyen típusra konvertálja az értéket. Ezt nevezzük más néven castolásnak is.

🎯 Célja

Amikor az automatikus típuskonverzió (implicit) nem történik meg.
Amikor pontosan szeretnénk szabályozni, milyen típusra konvertáljuk az értéket.
Amikor az implicit konverzió veszélyes vagy félreérthető lenne, ezért tudatos beavatkozás szükséges.

🧱 Szintaxis

1. C-stílusú cast (nem ajánlott modern C++-ban)

int a = (int)3.14;  // eredmény: 3

2. C++ stílusú cast (ajánlott)

Cast típusa	Szintaxis	Használat
`static_cast`	`static_cast<T>(expr)`	Általános, típusbiztos konverzió
`const_cast`	`const_cast<T>(expr)`	`const` vagy `volatile` eltávolítása
`reinterpret_cast`	`reinterpret_cast<T>(expr)`	Bitekvivalens, veszélyes konverzió
`dynamic_cast`	`dynamic_cast<T>(expr)`	Futásidejű típusellenőrzés (`RTTI`)

📦 Példák

1. `static_cast`

double d = 3.99;
int i = static_cast<int>(d);  // eredmény: 3

Ez biztonságos, veszteséges konverzió.

2. `const_cast`

void f(int* p) {
    // ...
}

const int x = 42;
f(const_cast<int*>(&x));

Figyelem! const_cast használata akkor biztonságos, ha valóban nem const memória áll mögötte.

3. `reinterpret_cast`

int i = 65;
char* p = reinterpret_cast<char*>(&i);
std::cout << *p;  // 'A' lehet

Nagyon veszélyes, ritkán ajánlott. Memóriabitenkénti nézetet vált.

4. `dynamic_cast` (polimorf típusokhoz)

class Base { public: virtual ~Base() = default; };
class Derived : public Base {};

Base* b = new Derived;
Derived* d = dynamic_cast<Derived*>(b);

Ha b nem Derived*, akkor d → nullptr. Csak polimorf osztályokon működik (virtual).

🧩 User-defined explicit konverzió

Osztályban definiált `explicit` operátor

class MyClass {
    int value;
public:
    MyClass(int v): value(v) {}

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

MyClass obj(42);
// int x = obj;         // ❌ nem engedélyezett
int y = static_cast<int>(obj);  // ✅ működik

Az explicit kulcsszó megakadályozza az implicit átalakítást, de engedi a kifejezett (explicit) castot.

✅ Összegzés

Fogalom	Leírás
Explicit konverzió	A programozó által meghatározott típusváltás
Modern szintaxis	`static_cast`, `dynamic_cast`, `const_cast`, `reinterpret_cast`
Használati esetek	Típusillesztés, const eltávolítás, polimorfia
Ajánlott	`static_cast`, `dynamic_cast`
Kerülendő	`reinterpret_cast`, C-stílusú cast (kivéve speciális esetben)

További információk

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