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,

mylivecricket

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

nbsp

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.

ako sa vymaniť zo slučky while java

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.