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,

polecenie arp-a

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

Klucz kandydata

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.

liczba całkowita na ciąg w Javie

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.