CASTING OPERATORS V C++

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í:

static_cast
dynamic_cast
const_cast
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,

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++

  // 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; }

Výstup

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++

  // 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; }

Výstup

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++

  // 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; }

Výstup

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++

  // 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; }

Výstup

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.