Operatory rzutowania są używane do rzutowania typów w C++. Służą do konwersji jednego typu danych na inny. C++ obsługuje cztery typy rzutowania:

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

1. static_cast

The static_cast operator jest najczęściej używanym operatorem rzutowania w C++. Wykonuje konwersję typów w czasie kompilacji i jest używany głównie do jawnych konwersji, które kompilator uważa za bezpieczne.

Składnia static_cast

  static_cast    <  new_type>(wyrażenie); 

Gdzie,

• wyrażenie: Dane do konwersji.
• nowy typ: Pożądany rodzaj wyrażenia

static_cast może służyć do konwersji między pokrewnymi typami, takimi jak typy liczbowe lub wskaźniki w tej samej hierarchii dziedziczenia.

Przykład 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 (liczba); // drukowanie typu danych cout < < typeid(num).name()  < < endl; // typecasting cout  < < typeid(static_cast (liczba)).nazwa() < < endl; // printing double type t cout  < < typeid(numDouble).name()  < < endl; return 0; } 

i d d 

W tym przykładzie uwzględniliśmy wpisz informacje bibliotekę, z której możemy korzystać wpisz() funkcja sprawdzająca typ danych. Zdefiniowaliśmy zmienną całkowitą „num” i przekonwertowaliśmy ją na liczbę podwójną za pomocą static_cast. Następnie drukujemy typy danych zmiennych i przekazujemy static_cast(liczba) W wpisz() funkcję sprawdzającą typ danych. widzimy, że wyjście i, d, d jest drukowane gdzie 'I' oznacza liczba całkowita I 'D' oznacza podwójnie .

2. dynamic_cast

The dynamic_cast operator jest używany głównie do wykonywania rzutowania w dół (konwertowania wskaźnika/odniesienia klasy bazowej do klasy pochodnej). Zapewnia bezpieczeństwo typu, przeprowadzając kontrolę w czasie wykonywania w celu sprawdzenia ważności konwersji.

Składnia dynamic_cast

  dynamic_cast    <  new_type>(wyrażenie); 

Jeżeli konwersja nie jest możliwa, dynamic_cast zwraca A wskaźnik zerowy (dla konwersji wskaźników) lub rzuca a wyjątek bad_cast (dla konwersji referencyjnych).

Przykład 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 (zwierzęPtr); // sprawdzanie, czy rzutowanie powiodło się if (dogPtr) { dogPtr->speak(); } else { przym < < 'Failed to cast to Dog.'  < < endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast (zwierzęPtr); if (catPtr) { catPtr->mów(); } else { przym < < 'Failed to cast to Cat.'  < < endl; } delete animalPtr; return 0; } 

Dog barks. Failed to cast to Cat. 

Wyjaśnienie: Wypisywany jest pierwszy wiersz wyniku, ponieważ „zwierzęPtr” z 'Zwierzę' typ został pomyślnie rzutowany na 'Pies' wpisz i mówić() wywoływana jest funkcja klasy Dog, ale rzutowanie klasy 'Zwierzę' wpisz do 'Kot' typ nie powiódł się, ponieważ „zwierzęPtr” wskazuje na A 'Pies' w ten sposób rzutowanie dynamiczne kończy się niepowodzeniem, ponieważ rzutowanie nie jest bezpieczne.

3. const_cast

The const_cast Operator służy do modyfikowania kwalifikatora const lub volatile zmiennej. Pozwala programistom tymczasowo usunąć stałość obiektu i wprowadzić modyfikacje. Należy zachować ostrożność podczas używania const_cast, ponieważ modyfikacja obiektu const może prowadzić do niezdefiniowanego zachowania.

Składnia const_cast

  const_cast    <  new_type>(wyrażenie); 

Przykład 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 

W powyższym przykładzie zmodyfikowaliśmy wartość parametru typ stały wskaźnik, zmieniając jego kwalifikator z konst Do nie-stała a następnie wydrukowanie zmodyfikowanej wartości.

4. reinterpretacja_castu

The operator reinterpret_cast służy do konwersji wskaźnika na dowolny inny typ wskaźnika. Nie sprawdza, czy przekonwertowany wskaźnik jest tego samego typu, czy nie.

Składnia reinterpret_cast

  reinterpret_cast    <  new_type>(wyrażenie); 

Przykład

// 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 (wskaźnik liczby); // Drukowanie adresów pamięci i wartości cout < < 'Integer Address: '  < < numberPointer  < < endl; cout  < < 'Char Address: '  < < reinterpret_cast (wskaźnik char) < < endl; return 0; } 

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c 

W powyższym przykładzie zdefiniowaliśmy zmienną int 'numer' a następnie zapisz adres „numeru” w „Wskaźnik liczby” typu int, po czym dokonaliśmy konwersji „Wskaźnik liczby” typu int do wskaźnika char, a następnie zapisz go w „charPointer” zmienny. Aby sprawdzić, czy wydrukowaliśmy adresy zarówno numberPointer, jak i charPointer. Aby wydrukować adres zapisany w „charPointer” reinterpretuj_cast służy do ominięcia mechanizmu sprawdzania typu języka C++ i umożliwienia wydrukowania wskaźnika jako ogólnego adresu pamięci bez jakiejkolwiek interpretacji specyficznej dla typu.

Notatka: const_cast i reinterpret_cast nie są ogólnie zalecane, ponieważ są podatne na różnego rodzaju błędy.