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,

pretvori niz v int java

• 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.

groovy jezik

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.