Operátory castingu sa používajú na typ casting v C++. Používajú sa na konverziu jedného typu údajov na iný. C++ podporuje štyri typy pretypovania:

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

1. static_cast

The static_cast Operátor je najbežnejšie používaným operátorom castingu v C++. Vykonáva konverziu typu v čase kompilácie a používa sa hlavne na explicitné konverzie, ktoré kompilátor považuje za bezpečné.

Syntax static_cast

  static_cast    <  new_type>(výraz); 

kde,

• výraz: Údaje na konverziu.
• nový_typ: Požadovaný typ prejavu

Parametr static_cast možno použiť na konverziu medzi súvisiacimi typmi, ako sú číselné typy alebo ukazovatele v rovnakej hierarchii dedičnosti.

Príklad 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 (počet); // tlač typu údajov cout < < typeid(num).name()  < < endl; // typecasting cout  < < typeid(static_cast (číslo)).meno() < < endl; // printing double type t cout  < < typeid(numDouble).name()  < < endl; return 0; } 

i d d 

V tomto príklade sme zahrnuli info o type knižnicu, aby sme ju mohli použiť typeid() funkcia na kontrolu typu údajov. Definovali sme celočíselnú premennú „num“ a skonvertovali sme ju na dvojitú pomocou static_cast. Potom vytlačíme dátové typy premenných a prejdeme static_cast(num) v typeid() na kontrolu jeho dátového typu. môžeme vidieť výstup i, d, d je vytlačený kde 'ja' označuje celé číslo a „d“ označuje dvojitý .

2. dynamic_cast

The dynamic_cast operátor sa používa hlavne na vykonávanie downcastingu (konvertovanie ukazovateľa/odkazu základnej triedy na odvodenú triedu). Zaisťuje bezpečnosť typu vykonaním kontroly za behu na overenie platnosti konverzie.

Syntax dynamic_cast

  dynamic_cast    <  new_type>(výraz); 

Ak konverzia nie je možná, dynamic_cast vracia a nulový ukazovateľ (pre prevody ukazovateľov) alebo hodí a výnimka bad_cast (pre referenčné konverzie).

Príklad 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); // kontrola, či je pretypovanie úspešné if (dogPtr) { dogPtr->speak(); } inak { cout < < 'Failed to cast to Dog.'  < < endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast (animalPtr); if (catPtr) { catPtr->speak(); } inak { cout < < 'Failed to cast to Cat.'  < < endl; } delete animalPtr; return 0; } 

Dog barks. Failed to cast to Cat. 

Vysvetlenie: Prvý riadok výstupu sa vytlačí, pretože ‘animalPtr’ z 'zviera' typ je úspešne odovzdaný do 'Pes' typu a hovoriť () funkcia triedy Dog je vyvolaná, ale obsadenie 'zviera' zadajte do 'mačka' typ zlyhal, pretože ‘animalPtr’ poukazuje na a 'Pes' objekt teda dynamické pretypovanie zlyhá, pretože typové obsadenie nie je bezpečné.

3. const_cast

The const_cast Operátor sa používa na úpravu konštantného alebo volatile kvalifikátora premennej. Umožňuje programátorom dočasne odstrániť nemennosť objektu a vykonať úpravy. Pri používaní const_cast je potrebné postupovať opatrne, pretože úprava objektu const môže viesť k nedefinovanému správaniu.

Syntax pre const_cast

  const_cast    <  new_type>(výraz); 

Príklad 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 

Vo vyššie uvedenom príklade sme upravili hodnotu const typ ukazovateľ zmenou jeho kvalifikátora z konšt do nekonšt a potom vytlačte upravenú hodnotu.

4. reinterpret_cast

The operátor reinterpret_cast sa používa na konverziu ukazovateľa na akýkoľvek iný typ ukazovateľa. Nevykonáva žiadnu kontrolu, či konvertovaný ukazovateľ je rovnakého typu alebo nie.

Syntax reinterpret_cast

  reinterpret_cast    <  new_type>(výraz); 

Príklad

// 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 (čísloPointer); // Tlač pamäťových adries a hodnôt cout < < 'Integer Address: '  < < numberPointer  < < endl; cout  < < 'Char Address: '  < < reinterpret_cast (charPointer) < < endl; return 0; } 

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c 

Vo vyššie uvedenom príklade sme definovali premennú typu int 'číslo' a potom uložte adresu „čísla“. 'numberPointer' typu int sme potom skonvertovali 'numberPointer' typu int do ukazovateľa char a potom ho uložte do „charPointer“ premenlivý. Aby sme overili, že sme vytlačili adresu numberPointer aj charPointer. Ak chcete vytlačiť adresu uloženú v „charPointer“ reinterpret_cast sa používa na obídenie mechanizmu kontroly typu v C++ a umožňuje vytlačenie ukazovateľa ako generickej adresy pamäte bez akejkoľvek interpretácie špecifickej pre daný typ.

Poznámka: const_cast a reinterpret_cast sa vo všeobecnosti neodporúčajú, pretože sú náchylné na rôzne druhy chýb.