Operatorji za pretvorbo se uporabljajo za pretvorbo tipa v C++. Uporabljajo se za pretvorbo enega tipa podatkov v drugega. C++ podpira štiri vrste ulitkov:

1. static_cast
2. dynamic_cast
3. const_cast
4. reinterpret_cast

1. static_cast

The static_cast operator je najpogosteje uporabljen operator za prelivanje v C++. Izvaja pretvorbo vrste med prevajanjem in se uporablja predvsem za eksplicitne pretvorbe, ki jih prevajalnik šteje za varne.

Sintaksa static_cast

  static_cast    <  new_type>(izraz); 

kje,

• izraz: Podatki za pretvorbo.
• nova_vrsta: Želena vrsta izražanja

Static_cast se lahko uporablja za pretvorbo med sorodnimi tipi, kot so številski tipi ali kazalci v isti hierarhiji dedovanja.

Primer static_cast

// C++ program to illustrate the static_cast #include  #include  using namespace std; int main() { int num = 10; // converting int to double double numDouble = static_cast (št.); // tiskanje podatkovnega tipa cout < < typeid(num).name()  < < endl; // typecasting cout  < < typeid(static_cast (število)).ime() < < endl; // printing double type t cout  < < typeid(numDouble).name()  < < endl; return 0; } 

i d d 

V tem primeru smo vključili typeinfo knjižnico, da jo lahko uporabljamo typeid() funkcijo za preverjanje vrste podatkov. Definirali smo celoštevilsko spremenljivko 'num' in jo pretvorili v dvojno z uporabo static_cast. Nato natisnemo podatkovne tipe spremenljivk in podamo static_cast(število) v typeid() funkcijo za preverjanje vrste podatkov. vidimo, da je rezultat i, d, d natisnjen kje 'jaz' označuje celo število in 'd' označuje dvojno .

2. dynamic_cast

The dynamic_cast operator se večinoma uporablja za izvajanje nizanja (pretvorba kazalca/sklica osnovnega razreda v izpeljani razred). Zagotavlja varnost tipa z izvajanjem preverjanja med izvajanjem, da preveri veljavnost pretvorbe.

Sintaksa dynamic_cast

  dynamic_cast    <  new_type>(izraz); 

Če pretvorba ni mogoča, dynamic_cast vrne a ničelni kazalec (za pretvorbe kazalcev) ali vrže a izjema bad_cast (za referenčne pretvorbe).

Primer dynamic_cast

// C++ program to illustrate the dynamic_cast #include  using namespace std; // Base Class class Animal { public: virtual void speak() const { cout  < < 'Animal speaks.'  < < endl; } }; // Derived Class class Dog : public Animal { public: void speak() const override { cout  < < 'Dog barks.'  < < endl; } }; // Derived Class class Cat : public Animal { public: void speak() const override { cout  < < 'Cat meows.'  < < endl; } }; int main() { // base class pointer to derived class object Animal* animalPtr = new Dog(); // downcasting Dog* dogPtr = dynamic_cast (animalPtr); // preverjanje, ali je pretvorba tipa uspešna if (dogPtr) { dogPtr->speak(); } else { cout < < 'Failed to cast to Dog.'  < < endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast (animalPtr); if (catPtr) { catPtr->speak(); } else { cout < < 'Failed to cast to Cat.'  < < endl; } delete animalPtr; return 0; } 

Dog barks. Failed to cast to Cat. 

Pojasnilo: Prva vrstica izhoda je natisnjena, ker je 'animalPtr' od 'Žival' vrsta je uspešno pretvorjena v 'pes' tip in govoriti() je priklicana funkcija razreda Dog, vendar je ulivanje 'Žival' tip do 'Mačka' vrsta ni uspela, ker 'animalPtr' kaže na a 'Pes' tako dinamična pretvorba ne uspe, ker pretvorba tipa ni varna.

3. const_cast

The const_cast se uporablja za spreminjanje kvalifikatorja const ali volatile spremenljivke. Programerjem omogoča, da začasno odstranijo stalnost predmeta in izvedejo spremembe. Pri uporabi const_cast je potrebna previdnost, saj lahko spreminjanje objekta const povzroči nedefinirano vedenje.

Sintaksa za const_cast

  const_cast    <  new_type>(izraz); 

Primer const_cast

// C++ program to illustrate the const_cast #include  using namespace std; int main() { const int number = 5; // Pointer to a const int const int* ptr = &number; // int* nonConstPtr = ptr; if we use this // instead of without using const_cast // we will get error of invalid conversion int* nonConstPtr = const_cast (ptr); *nonConstPtr = 10; cout < < 'Modified number: '  < < *nonConstPtr; return 0; } 

Modified number: 10 

V zgornjem primeru smo spremenili vrednost tip const kazalec s spremembo njegovega kvalifikatorja iz konst do nekonst in nato natisnete spremenjeno vrednost.

4. reinterpret_cast

The operator reinterpret_cast se uporablja za pretvorbo kazalca v katero koli drugo vrsto kazalca. Ne izvede nobenega preverjanja, ali je pretvorjeni kazalec iste vrste ali ne.

Sintaksa reinterpret_cast

  reinterpret_cast    <  new_type>(izraz); 

Primer

// C++ program to illustrate the reinterpret_cast #include  using namespace std; int main() { int number = 10; // Store the address of number in numberPointer int* numberPointer = &number; // Reinterpreting the pointer as a char pointer char* charPointer = reinterpret_cast (numberPointer); // Tiskanje pomnilniških naslovov in vrednosti cout < < 'Integer Address: '  < < numberPointer  < < endl; cout  < < 'Char Address: '  < < reinterpret_cast (charPointer) < < endl; return 0; } 

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c 

V zgornjem primeru smo definirali spremenljivko int 'številka' in nato shranite naslov 'številke' 'numberPointer' tipa int, potem pa smo pretvorili 'numberPointer' tipa int v kazalec char in ga nato shranite v 'charPointer' spremenljivka. Za preverjanje, ali smo natisnili naslov tako numberPointer kot charPointer. Za tiskanje naslova, shranjenega v 'charPointer' reinterpret_cast se uporablja za obhod mehanizma za preverjanje tipa C++ in omogoča, da se kazalec natisne kot generični pomnilniški naslov brez interpretacije, specifične za tip.

Opomba: const_cast in reinterpret_cast na splošno nista priporočljiva, ker sta ranljiva za različne vrste napak.