Casting operátory se používají pro typ casting v C++. Používají se k převodu jednoho datového typu na jiný. C++ podporuje čtyři typy přetypování:

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

1. static_cast

The static_cast Operátor je nejběžněji používaným castingovým operátorem v C++. Provádí převod typu v době kompilace a používá se hlavně pro explicitní převody, které kompilátor považuje za bezpečné.

Syntaxe static_cast

  static_cast   <  new_type>(výraz);>

kde,

int do řetězce java

• výraz: Data ke konverzi.
• nový_typ: Požadovaný typ výrazu

Parametr static_cast lze použít k převodu mezi souvisejícími typy, jako jsou číselné typy nebo ukazatele ve stejné hierarchii dědičnosti.

Pří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); // tisk datového typu cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(num)).name()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>

i d d>

V tomto příkladu jsme zahrnuli info o typu knihovnu, abychom ji mohli používat typid() funkce pro kontrolu datového typu. Definovali jsme celočíselnou proměnnou ‚num‘ a převedli ji na double pomocí static_cast. Poté vytiskneme datové typy proměnných a předáme static_cast(num) v typid() funkci pro kontrolu jeho datového typu. můžeme vidět výstup i, d, d je vytištěn kde 'já' označuje celé číslo a 'd' označuje dvojnásobek .

2. dynamic_cast

The dynamic_cast operátor se používá hlavně k provádění downcastingu (převod ukazatele/odkazu na základní třídu na odvozenou třídu). Zajišťuje bezpečnost typu tím, že provádí kontrolu za běhu pro ověření platnosti převodu.

Syntaxe dynamic_cast

  dynamic_cast   <  new_type>(výraz);>

Pokud převod není možný, dynamic_cast vrací a nulový ukazatel (pro převod ukazatelů) nebo vyvolá a výjimka bad_cast (pro referenční konverze).

Pří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, zda je přetypování úspěšné if (dogPtr) { dogPtr->speak(); } jinak { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(animalPtr); if (catPtr) { catPtr->speak(); } jinak { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>

Dog barks. Failed to cast to Cat.>

Vysvětlení: První řádek výstupu se vytiskne, protože 'animalPtr' z 'Zvíře' typ je úspěšně přetypován do 'Pes' typu a mluvit() funkce třídy Dog je vyvolána, ale obsazení 'Zvíře' zadejte do 'Kočka' typ selhal, protože 'animalPtr' ukazuje na a 'Pes' objektu tedy dynamické přetypování selže, protože typové přetypování není bezpečné.

3. const_cast

The const_cast Operátor se používá k úpravě konst nebo volatile kvalifikátoru proměnné. Umožňuje programátorům dočasně odstranit stálost objektu a provádět úpravy. Při použití const_cast je třeba postupovat opatrně, protože úprava objektu const může vést k nedefinovanému chování.

Syntaxe pro const_cast

  const_cast   <  new_type>(výraz);>

Pří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>

Ve výše uvedeném příkladu jsme upravili hodnotu the typ const ukazatel změnou jeho kvalifikátoru z konst na nekonst a poté vytisknout upravenou hodnotu.

4. reinterpret_cast

The operátor reinterpret_cast se používá k převodu ukazatele na jakýkoli jiný typ ukazatele. Neprovádí žádnou kontrolu, zda převedený ukazatel je stejného typu nebo ne.

Syntaxe reinterpret_cast

  reinterpret_cast   <  new_type>(výraz);>

Pří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); // Tisk adres paměti a hodnot cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>

Ve výše uvedeném příkladu jsme definovali proměnnou int 'číslo' a poté uložte adresu „čísla“. ‘numberPointer’ typu int jsme poté převedli ‘numberPointer’ typu int do ukazatele char a poté jej uložte do „charPointer“ variabilní. Abychom ověřili, že jsme vytiskli adresu numberPointer i charPointer. Chcete-li vytisknout adresu uloženou v „charPointer“ reinterpret_cast se používá k obcházení mechanismu kontroly typu v C++ a umožňuje vytištění ukazatele jako generické adresy paměti bez jakékoli typově specifické interpretace.

Poznámka: const_cast a reinterpret_cast se obecně nedoporučují, protože jsou náchylné na různé druhy chyb.