Ugrás a tartalomhoz

implicit type conversion

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


Főnév

implicit type conversion (tsz. implicit type conversions)

  1. (informatika) Az implicit type conversion (implicit típuskonverzió) C++-ban azt jelenti, hogy a fordító automatikusan átalakítja egy kifejezés típusát egy másik, kompatibilis típussá, amikor ez szükséges a kód értelmezéséhez. Ezt nevezik más néven type coercion-nek is.



🧠 Alapgondolat

A fordító magától végrehajtja a típusátalakítást, ha az értelmes és biztonságos:

int i = 5;
double d = i;  // implicit: int → double

🔁 Mikor történik implicit konverzió?

  1. Értékadáskor:
double d = 42;  // int → double automatikusan
  1. Kifejezésekben:
int a = 5;
double b = 2.5;
auto c = a + b;  // int + double → double
  1. Függvényhíváskor:
void f(double x);

f(3);  // int → double
  1. Felhasználó által definiált konverziók (constructor vagy operator)



📦 Beépített konverziók

Növekvő sorrend (promotion):

char  int  float  double  long double

Példák:

char c = 'A';
int i = c;  // 'A' → 65
float f = 3;
double d = f;  // float → double

🧩 Felhasználói típuskonverziók

C++ lehetővé teszi, hogy saját osztályaink is rendelkezzenek implicit konverzióval.

Példa: implicit konstruktor

class Meter {
    double value;
public:
    Meter(double v): value(v) {}
};

void printMeter(const Meter& m);

printMeter(5.0);  // implicit: double → Meter

Explicit tiltás:

explicit Meter(double v);  // csak `Meter(5.0)` engedélyezett, implicit nem

Implicit operator T() konverzió

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

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

IntWrapper w(42);
int i = w;  // implicit: IntWrapper → int

⚠️ Veszélyei

Veszély Magyarázat
Veszteséges konverzió pl. double → int lecsapja a tört részt
Típusütközés pl. túlterhelt függvényeknél félrevezető lehet
Nem várt viselkedés ha implicit konstruktorok/konverziók vannak, akár bugokat is okozhatnak



✅ Összegzés

Tulajdonság Leírás
Mit jelent? A fordító automatikusan konvertál kompatibilis típusokra
Mikor történik? Értékadás, kifejezések, függvényhívás
Mire terjed ki? Beépített típusokra, felhasználói osztályokra is
Hogyan szabályozható? explicit kulcsszóval
Veszélye? Rejtett hibák, elveszett adatok