Dokumentacja C z przykładami: Rzutowanie typów

Q: Jak rzutować w C?

Umieść typ docelowy w nawiasach przed wartością: (double)x, (int)3.9, (char)65. Rzutowanie dotyczy wyrażenia tuż za nim, więc (double)a / b najpierw konwertuje a, a potem dzieli, natomiast (double)(a / b) dzieli jak liczby całkowite i konwertuje dopiero wynik.

Q: Jak zamienić int na float w C?

Przypisanie robi to niejawnie: double d = 5; zapisuje 5.0. Wewnątrz wyrażenia często potrzebne jest jawne rzutowanie: (double)total / count wymusza dzielenie zmiennoprzecinkowe zamiast całkowitego.

C bez przerwy konwertuje wartości między typami. Część tych konwersji zapisujesz sam za pomocą rzutowania, ale większość kompilator wykonuje po cichu według zasad, których nie wybierasz. Wiedza o tym, która jest która, to różnica między „dlaczego moja średnia to zawsze 3?” a kodem, który robi to, co mówi.

Konwersja niejawna

Za każdym razem, gdy wartość jednego typu trafia w miejsce oczekujące innego, C ją konwertuje:

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0, dokladnie */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3, .9 przepadlo */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

Konwersje, które nie mogą zgubić informacji (int na double, char na int, short na long), są rozszerzające i zawsze bezpieczne. Konwersje w drugą stronę są zawężające i mogą gubić dane: powyższe 3.9 stało się 3 bez żadnego ostrzeżenia, chyba że poprosisz o nie przez -Wconversion.

Zwykłe konwersje arytmetyczne

Gdy operator dwuargumentowy ma operandy różnych typów, C przed wykonaniem działania konwertuje je do wspólnego typu. Drabina, od dołu:

Wszystko mniejsze niż int (char, short, _Bool) jest promowane do int. To promocja całkowita i dzieje się zawsze jako pierwsza.
Jeśli któraś strona to long double, druga staje się long double.
W przeciwnym razie, jeśli któraś to double, druga staje się double.
W przeciwnym razie, jeśli któraś to float, druga staje się float.
W przeciwnym razie, wśród typów całkowitych wygrywa ten o wyższej randze, a przy remisie wygrywa typ bez znaku.

Ta ostatnia zasada powoduje prawdziwe błędy. Pozostałe są intuicyjne.

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a i b sa najpierw promowane do int, wiec 10000 sie miesci. */
    printf("a * b jako int = %d\n", a * b);

    /* Ale zapisanie wyniku z powrotem w char znowu go zaweza. */
    char product = a * b;
    printf("zapisane w char = %d\n", product);
    return 0;
}

Promocja całkowita wyjaśnia, dlaczego arytmetyka na char nie przepełnia się tak, jak można by się spodziewać, oraz dlaczego zapisanie wyniku z powrotem w char już tak.

Jawne rzutowanie

Rzutowanie to typ docelowy w nawiasach:

(double)x
(int)3.9
(char)65
(unsigned int)n

Dotyczy wyrażenia tuż za nim i wiąże bardzo mocno: mocniej niż *, / czy +.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("bez rzutowania:     %f\n", (double)(total / count));  /* 3.0 */
    printf("najpierw rzutowanie: %f\n", (double)total / count);   /* 3.5 */
    printf("rzutowanie obu:     %f\n", (double)total / (double)count);
    return 0;
}

Pierwsza linia dzieli jak liczby całkowite (co daje 3), a potem zamienia 3 na 3.0, czyli za późno. Druga zamienia total na double przed dzieleniem, więc operator / widzi double i int, promuje int i wykonuje dzielenie zmiennoprzecinkowe, które daje 3.5.

Rzutowanie jednego operandu wystarczy. Zwykłe konwersje arytmetyczne zajmą się drugim.

Naprawa dzielenia całkowitego

To najczęstszy powód, by napisać rzutowanie w C:

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("suma = %d\n", sum);
    printf("zla srednia:       %f\n", (double)(sum / n));    /* 81.000000: dzielenie na int, a POTEM konwersja */
    printf("poprawna srednia:  %f\n", (double)sum / n);      /* 81.200000 */

    /* Procenty maja te sama pulapke. */
    int passed = 3;
    printf("zly procent:      %d%%\n", passed / n * 100);       /* 0 procent */
    printf("poprawny procent: %.1f%%\n", 100.0 * passed / n);   /* 60.0 procent */
    return 0;
}

Linia z procentami jest pouczająca: passed / n to 3 / 5, czyli 0 w liczbach całkowitych, a 0 * 100 to 0. Mnożenie przed dzieleniem (100 * passed / n) naprawia to nawet bez rzutowania, bo 300 / 5 dzieli się bez reszty, ale to działa tylko wtedy, gdy liczby współpracują. Rzutowanie to niezawodna poprawka.

Obcinanie, a nie zaokrąglanie

Rzutowanie wartości zmiennoprzecinkowej na liczbę całkowitą odrzuca część ułamkową. Obcina w stronę zera, nie zaokrągla:

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 3, a nie 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3, a nie -4 */

    /* Prawdziwe zaokraglanie z math.h: */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

Jeśli budujesz to na własnej maszynie, pamiętaj, że math.h na Linuksie wymaga -lm przy linkowaniu.

Jeszcze jedno zagrożenie: konwersja wartości zmiennoprzecinkowej zbyt dużej dla typu całkowitego to niezdefiniowane zachowanie, a nie zawinięcie. (int)1e20 może dać cokolwiek. Gdy wartość nie jest pod twoją kontrolą, sprawdź zakres przed rzutowaniem.

char i int

char w C jest małą liczbą całkowitą przechowującą kod znaku. Konwersja między nimi to codzienność:

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' ma kod %d\n", letter, code);
    printf("code + 1 to '%c'\n", (char)(code + 1));   /* 'B' */

    /* Znak cyfry na jej wartosc liczbowa: */
    char digit = '7';
    int value = digit - '0';
    printf("znak '%c' jako liczba to %d\n", digit, value);

    /* Wielkie litery na male, dzieki stalej roznicy 32 pozycji w ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' to standardowy idiom zamiany znaku cyfry na jej wartość i działa, bo dziesięć znaków cyfr ma gwarancję, że są kolejne. Dla liter wybieraj toupper() i tolower() z ctype.h zamiast arytmetyki z + 32: to przesunięcie to fakt z ASCII, a nie gwarancja C.

Pokrewna pułapka: funkcje z ctype.h, takie jak isdigit i toupper, przyjmują int, który musi być albo EOF, albo wartością dającą się przedstawić jako unsigned char. Przekazanie ujemnego zwykłego char (co jest możliwe, bo zwykły char może mieć znak) to niezdefiniowane zachowanie. Rzutuj: isdigit((unsigned char)c).

Pułapka signed/unsigned

Krok 5 drabiny konwersji, czyli wygrana typu bez znaku przy remisie, daje najbardziej zaskakujące porównanie w C:

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1 jest mniejsze od 1  (tego sie spodziewasz)\n");
    } else {
        printf("-1 NIE jest mniejsze od 1  (to naprawde mowi C)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1 jest konwertowane na unsigned int, co odczytuje jego wzorzec bitów jako 4 294 967 295. To więcej niż 1, więc porównanie jest fałszywe.

Ta sama konwersja sprawia, że pętle kręcą się w nieskończoność:

/* BLAD: i jest bez znaku, wiec i >= 0 jest zawsze prawda. Gdy i wynosi 0, i-- sie zawija. */
for (size_t i = n - 1; i >= 0; i--) { ... }

I że sprawdzanie długości zawodzi:

/* BLAD: strlen zwraca size_t (bez znaku). Jesli napis jest krotszy
   niz 5, len - 5 zawija sie do ogromnej liczby i test przechodzi. */
if (strlen(s) - 5 > 0) { ... }

Przepisz to jako if (strlen(s) > 5), a odejmowanie w ogóle nie nastąpi.

Obrona: trzymaj liczniki i indeksy w jednym rodzaju znakowości, kompiluj z -Wsign-compare (zawarte w -Wextra), a gdy musisz je mieszać, rzutuj jawnie po upewnieniu się, że wartość nie może być ujemna.

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *s = "hi";
    size_t len = strlen(s);

    /* Bezpiecznie: porownanie bez odejmowania. */
    if (len > 5) {
        printf("dlugi\n");
    } else {
        printf("krotki, znakow: %zu\n", len);
    }

    /* Bezpiecznie: rzutowanie na typ ze znakiem, gdy wiadomo, ze wartosc jest mala. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

Rzutowanie wskaźników

Rzutowanie konwertuje też między typami wskaźników i tu niesie realne ryzyko, bo zmienia sposób, w jaki pamięć jest interpretowana, a nie same bajty.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* Podejrzyj bajty int przez wskaznik na char. */
    unsigned char *bytes = (unsigned char *)&value;

    printf("int 1 jest zapisany jako bajty:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

Na maszynie little-endian to wypisuje 01 00 00 00. Podglądanie reprezentacji obiektu przez unsigned char * to jedno z niewielu rzutowań wskaźników, które standard wprost dopuszcza.

Większość innych rzutowań wskaźników nie jest dopuszczona. Odczyt int przez float * łamie regułę strict aliasing i jest niezdefiniowanym zachowaniem, choć się kompiluje. Do ponownej interpretacji bajtów użyj zamiast tego memcpy.

Dwie konwencje warte poznania. void * konwertuje się w C na dowolny typ wskaźnika na obiekt i z powrotem bez rzutowania, i dlatego nie należy rzutować wyniku malloc:

int *arr = malloc(n * sizeof *arr);        /* poprawne C */
int *arr = (int *)malloc(n * sizeof *arr); /* zbedne; ukrywa brakujacy naglowek */

Rzutowanie jest wymagane w C++ i dlatego tyle kodu je zawiera. W C może ukryć błąd zapomnianego <stdlib.h>.

Natomiast printf("%p", ...) oczekuje void *, więc tam argumenty wskaźnikowe naprawdę wymagają rzutowania: printf("%p", (void *)p).

Kiedy rzutowanie to zła odpowiedź

Rzutowanie ucisza kompilator. Czasem kompilator miał rację.

long big = 5000000000L;
int  small = (int)big;    /* rzutowanie ukrywa realna utrate danych */

Jeśli wartość naprawdę się mieści, rzutowanie dokumentuje, że to sprawdzono. Jeśli może się nie mieścić, rzutowanie zamieniło ostrzeżenie w cichą złą odpowiedź. Zanim je napiszesz, zastanów się, czy poprawką nie jest zmiana typu zmiennej: double zamiast int, size_t zamiast int, long long zamiast long. Rzutowanie to właściwe narzędzie głównie wtedy, gdy dwa poprawne typy muszą się spotkać w jednej operacji, jak w (double)sum / count.

Najczęściej zadawane pytania

Jak rzutować w C?

Umieść typ docelowy w nawiasach przed wartością: (double)x, (int)3.9, (char)65. Rzutowanie dotyczy wyrażenia tuż za nim, więc (double)a / b najpierw konwertuje a, a potem dzieli, natomiast (double)(a / b) dzieli jak liczby całkowite i konwertuje dopiero wynik.

Jak zamienić int na float w C?

Przypisanie robi to niejawnie: double d = 5; zapisuje 5.0. Wewnątrz wyrażenia często potrzebne jest jawne rzutowanie: (double)total / count wymusza dzielenie zmiennoprzecinkowe zamiast całkowitego.

Co się dzieje przy rzutowaniu float na int w C?

Część ułamkowa jest odrzucana: obcinana w stronę zera, nigdy zaokrąglana. (int)3.9 to 3, a (int)-3.9 to -3. Aby zaokrąglić, dla liczb dodatnich dodaj 0.5 przed rzutowaniem albo użyj round(), floor() lub ceil() z math.h.

Dlaczego porównanie int ze znakiem i bez znaku daje złą odpowiedź?

Zwykłe konwersje arytmetyczne w C zamieniają wartość ze znakiem na wartość bez znaku, więc -1 < 1u jest fałszem: -1 staje się ogromną liczbą dodatnią. Trzymaj liczniki i rozmiary w jednym rodzaju znakowości albo rzutuj jawnie po sprawdzeniu, że wartość nie może być ujemna.

Powiązane zagadnienia