Rzutowanie typów w C++: static_cast i konwersje niejawne

Czym jest rzutowanie typów

Rzutowanie typów (type casting) to konwersja wartości z jednego typu na inny: zamiana double na int, char na jego kod liczbowy albo wskaźnika na klasę bazową na wskaźnik na klasę pochodną. Część tych konwersji C++ wykonuje automatycznie, ale właśnie w tych cichych kryją się błędy.

Są dwa rodzaje: konwersje niejawne, które dzieją się same, oraz jawne rzutowania, które zapisujesz w kodzie. Jeden z objawów znasz już ze strony o operatorach: dzielenie całkowite. Rzutowanie pozwala przejąć nad nim kontrolę.

Konwersje niejawne

Gdy mieszasz w wyrażeniu różne typy liczbowe, C++ promuje "mniejszy" typ do "większego", żeby obie strony pasowały. Zwykle robi to, czego oczekujesz.

#include <iostream>
using namespace std;

int main() {
    int apples = 3;
    double price = 1.5;

    double total = apples * price;   // int -> double automatycznie
    cout << total << endl;           // 4.5

    char c = 'A';
    int code = c;                    // char -> int (kod ASCII)
    cout << code << endl;            // 65
    return 0;
}

Kłopoty zaczynają się, gdy konwersja idzie w przeciwną stronę: z szerszego typu do węższego. To konwersja zawężająca (narrowing) i może po cichu gubić dane.

#include <iostream>
using namespace std;

int main() {
    double pi = 3.99;
    int rounded = pi;        // zawężanie: część ułamkowa jest odrzucana, NIE zaokrąglana
    cout << rounded << endl; // 3

    int big = 300;
    char small = big;        // 300 nie mieści się w char
    cout << static_cast<int>(small) << endl; // 44 (zawinięte!)
    return 0;
}

Zamiana liczby zmiennoprzecinkowej na całkowitą obcina w stronę zera: nie zaokrągla, więc 3.99 staje się 3. A wciśnięcie 300 do char powoduje przepełnienie. Wiele kompilatorów tu ostrzega, niektóre nie. Gdy naprawdę chcesz zawęzić wartość, zapisz to jawnie rzutowaniem, żeby kolejna osoba czytająca kod wiedziała, że to celowe.

Jak ominąć pułapkę dzielenia całkowitego

Najczęstszy powód rzutowania to dzielenie. Gdy oba operandy są całkowite, / wykonuje dzielenie całkowite i wyrzuca resztę.

#include <iostream>
using namespace std;

int main() {
    int got = 7;
    int total = 10;

    double wrong = got / total;                       // 0  (najpierw dzielenie całkowite!)
    double right = static_cast<double>(got) / total;  // 0.7

    cout << wrong << endl;
    cout << right << endl;
    return 0;
}

Rozwiązanie to static_cast<double> na jednym operandzie przed dzieleniem. Częsty błąd to static_cast<double>(got / total): to za późno, bo w chwili rzutowania got / total ma już wartość 0, więc dostajesz 0.0. Rzutuj operand, nie wynik.

static_cast: rzutowanie domyślne

C++ oferuje cztery nazwane rzutowania. Tego, którego użyjesz w 95% przypadków, zapisuje się jako static_cast<T>(value): wykonuje ono dobrze zdefiniowane konwersje między powiązanymi typami, czyli konwersje liczbowe, enum na int, void* z powrotem na wskaźnik z typem oraz przejścia w górę i w dół hierarchii klas, gdy znasz już typ.

#include <iostream>
using namespace std;

int main() {
    double balance = 19.95;
    int dollars = static_cast<int>(balance);   // 19, część ułamkowa odrzucona

    int letter = 100;
    char ch = static_cast<char>(letter);       // 'd'

    cout << dollars << endl;   // 19
    cout << ch << endl;        // d
    return 0;
}

Wybieraj static_cast zamiast starego rzutowania w stylu C (int)balance. Rzutowanie w stylu C spróbuje dowolnej konwersji, byle kod się skompilował, łącznie z niebezpiecznymi opisanymi niżej, więc może po cichu usunąć const albo zinterpretować surowe bajty na nowo. static_cast pozwala tylko na konwersje, które kompilator potrafi uzasadnić, a rozwlekły zapis static_cast<...> łatwo wyszukać podczas code review.

// Unikaj: rzutowanie w stylu C, bez siatki bezpieczeństwa:
int dollars = (int) balance;

// Wybieraj: jawne, sprawdzane, łatwe do wyszukania:
int dollars = static_cast<int>(balance);

Pozostałe trzy rzutowania (używaj oszczędnie)

Pozostałe rzutowania istnieją do konkretnych, wąskich zadań. Sięgaj po nie tylko wtedy, gdy static_cast naprawdę nie wystarczy.

const_cast usuwa (lub dodaje) const. Jego jedyne uzasadnione zastosowanie to wywołanie API w stylu C, które zapomniało oznaczyć parametr jako const. Modyfikowanie przez const_cast obiektu, który pierwotnie zadeklarowano jako const, to niezdefiniowane zachowanie.

void legacyApi(char* msg);   // stare API, nie przyjmuje const

const char* text = "hello";
legacyApi(const_cast<char*>(text));   // w porządku tylko wtedy, gdy legacyApi do niego nie zapisuje

reinterpret_cast interpretuje na nowo surowy wzorzec bitów, na przykład wskaźnik jako całkowity adres. Nie wykonuje żadnej konwersji i jest skrajnie niebezpieczne: prawie zawsze to sygnał, że warto przemyśleć projekt.

dynamic_cast bezpiecznie konwertuje wskaźnik lub referencję do klasy bazowej w dół, do typu pochodnego, w czasie działania programu, na podstawie rzeczywistego typu obiektu. Wymaga polimorficznej klasy bazowej (klasy z co najmniej jedną funkcją wirtualną) i zwraca nullptr, gdy rzutowanie się nie udaje.

#include <iostream>
using namespace std;

struct Animal { virtual ~Animal() = default; };
struct Dog : Animal { void bark() { cout << "Woof!" << endl; } };

int main() {
    Animal* a = new Dog();

    if (Dog* d = dynamic_cast<Dog*>(a)) {  // udaje się: a naprawdę jest Dog
        d->bark();
    } else {
        cout << "not a Dog" << endl;
    }

    delete a;
    return 0;
}

Gdyby a wskazywało na jakieś inne Animal, dynamic_cast<Dog*> zwróciłoby nullptr i wykonałaby się gałąź else. Właśnie dlatego jest to bezpieczniejsze niż ślepe użycie static_cast do schodzenia w dół hierarchii.

Częste błędy

• Rzutowanie wyniku zamiast operandu. static_cast<double>(a / b) najpierw gubi część ułamkową. Rzutuj a albo b.
• Założenie, że zamiana na int zaokrągla. Ona obcina: static_cast<int>(2.99) to 2. Do zaokrąglania służą std::round, std::lround i podobne.
• Sięganie po rzutowanie w stylu C. Ukrywa ono, jaka konwersja zachodzi. Z static_cast dostaniesz błąd kompilacji przy niebezpiecznej konwersji zamiast cichej niespodzianki.
• Zawężanie do zbyt małego typu. Rzutowanie 300 na char albo ogromnego long na int powoduje zawinięcie lub przepełnienie. Wybierz typ docelowy wystarczająco szeroki dla zakresu wartości.

Dalej: if-else

Skoro potrafisz już czysto konwertować i porównywać wartości, następny krok to podejmowanie na ich podstawie decyzji. Instrukcja if-else wykonuje różny kod w zależności od tego, czy warunek jest true: to fundament każdego programu z rozgałęzieniami.