:~$ newsletter --subscribe
cat ~/artykuly/programowanie/operatory-rzutowania-w-c.md

Operatory rzutowania w C++

Czasami podczas pisania programów komputerowych musimy przypisać jakąś daną załóżmy typu double do innej zmiennej, która niestety jest już innego typu. W takim przypadku z pomocą przychodzą nam tak zwane operatory rzutowania, które w C++ przeszły w ostatnim czasie niemalże rewolucję. Nie będę na łamach tego artykułu opisywał starych (co ciekawe dalej działających) technik konwersji różnego rodzaju danych ale skupię się tutaj na nowych, zgodnych z obecnym standardem operatorach rzutowania.

C++ oferuje nam 4 operatory rzutowania, takie jak:

  1. static_cast<nazwaTypuNaKtoryChcemyZrzutowacJakasDana>(wyrazenie);
  2. const_cast<nazwaTypuNaKtoryChcemyZrzutowacJakasDana>(wyrazenie);
  3. dynamic_cast<nazwaTypuNaKtoryChcemyZrzutowacJakasDana>(wyrazenie);
  4. reinterpret_cast<nazwaTypuNaKtoryChcemyZrzutowacJakasDana>(wyrazenie);

static_cast

static_cast wykorzystujemy do konwersji danych zapisanych w zmiennych różnych typów:

cpp
#include <iostream>

using namespace std;

int main()
{
     double liczbaPI = 3.14;
     int liczbaPIpoKonwersji = static_cast<int>(liczbaPI);

     cout << liczbaPI << endl; //wypisze 3.14
     cout << liczbaPIpoKonwersji; //wypisze 3 zamiast 3.14;

     return 0;
}

const_cast

const_cast wykorzystujemy do konwersji stałych na zmienne, zmiennych na stałe lub stałych jakiegoś typu na stałe innego typu (uwaga: nie można jednocześnie rzutować jakiejś stałej na zmienną innego typu i odwrotnie):

cpp
#include <iostream>

using namespace std;

int main()
{
     const double liczbaPI = 3.14;
     const double *wskDoStalej = &liczbaPI;

     double *wskaznik = const_cast<double *>(wskDoStalej); //przypisujemy dane ze stałej do zwykłego wskaźnika

     cout << *wskaznik << endl; //wypisze 3.14

     return 0;
}

UWAGA: Używając const_cast należy operować na wskaźnikach.

dynamic_cast

dynamic_cast wykorzystujemy między innymi dla typów polimorficznych. Na łamach tego artykułu nie będę się rozpisywał jak to działa bowiem jest to strasznie rozległy temat nadający się na odrębny wpis. Ograniczę się więc tylko do zaprezentowania przykładowego kodu:

cpp
#include <iostream>

using namespace std;

struct A //struktura A
{
    virtual ~A()
    { };
};

struct B : A //struktura B dziedzicząca po A
{ };

int main()
{
    B objekt;
    A *wsk = &objekt; //wskaźnik na obiekt typu B

    void *wsk2 = dynamic_cast<void *>(wsk); //rzutowanie dynamic_cast (na wskaźnikach)

    cout << "wsk: " << wsk << endl;
    cout << "wsk2: " << wsk2 << endl;
    cout << "obiekt: " << &objekt << endl;

    return 0;
}

reinterpret_cast

reinterpret_cast używamy do rzutowania wskaźników (a właściwie adresów które przechowują) na inny typ. Jeżeli mamy na przykład wskaźnik, który wskazuje na komórki pamięci typu double, a chcemy zapisać jego zawartość (czyli adres na który wskazuje) do wskaźnika przeznaczonego na typ int to musimy właśnie użyć tego operatora rzutowania:

cpp
#include <iostream>

using namespace std;

int main()
{
    double *wsk;
    double liczba = 5;
    wsk = &liczba; //przypisujemy jakieś dane do wskaźnika (żeby wiedzieć na co pokazuje)

    cout << wsk << endl; //wypisz adres przechowywany przez wskaźnik 'wsk'

    int *wsk2;
    wsk2 = reinterpret_cast<int *>(wsk); //teraz przypisujemy do 'wsk2' typu int adres ze wskaźnika 'wsk' typu double

    cout << wsk2; //wypisz adres przechowywany przez wskaźnik 'wsk2'

    return 0;
}

Który operator rzutowania wybrać?

Cztery operatory to na początku sporo do zapamiętania, dlatego krótka ściąga, która pomaga wybrać właściwy w konkretnej sytuacji:

  • static_cast – codzienny wybór do bezpiecznych, sprawdzalnych na etapie kompilacji konwersji: liczby (int na double), rzutowanie w górę hierarchii dziedziczenia, jawne wywołanie konwersji, którą i tak zna kompilator.
  • dynamic_cast – do rzutowania w dół hierarchii (z klasy bazowej na pochodną), gdy chcemy mieć pewność, że obiekt naprawdę jest tego typu. Przy niepowodzeniu zwraca nullptr (dla wskaźników), więc wynik zawsze warto sprawdzić. Wymaga typów polimorficznych (z funkcją wirtualną).
  • const_cast – jedyny operator, który zdejmuje (lub dokłada) const. Używamy go rzadko, głównie do współpracy ze starszym API, które nie deklaruje const, choć wartości nie zmienia.
  • reinterpret_cast – narzędzie ostateczne, które dosłownie reinterpretuje bity jednego typu jako inny (np. wskaźnik na liczbę). Potężne i niebezpieczne, sięgaj po nie tylko wtedy, gdy naprawdę wiesz, co robisz.

Prosta zasada na start: dopóki wystarcza static_cast, używaj właśnie jego. Po dynamic_cast sięgaj przy hierarchiach klas, a dwa pozostałe traktuj jako wyjątki od reguły.

A co ze starym rzutowaniem w stylu C?

Zapewne spotkałeś się z krótszym zapisem rodem z języka C, w którym typ podaje się w nawiasie przed wartością:

cpp
double pi = 3.14;
int x = (int)pi;              // rzutowanie w stylu C
int y = static_cast<int>(pi); // to samo, ale po nowemu

Obie linie dają ten sam wynik, ale w C++ lepiej wybrać drugą. Rzutowanie w stylu C jest niejawne, bo kompilator próbuje po kolei static_cast, const_cast i reinterpret_cast, więc jednym nawiasem można przypadkiem zdjąć const albo przereinterpretować bity, wcale tego nie chcąc. Operatory nazwane jasno mówią o intencji, łatwiej je też wyszukać w kodzie. Dlatego w nowym kodzie C++ przyjęło się używać czterech operatorów opisanych wyżej, a zapis w stylu C zostawić dla samego języka C.