Type Casting di C: Konversi Implisit dan Cast Eksplisit

C terus-menerus mengonversi nilai antartipe. Sebagian konversi itu kamu tulis sendiri dengan cast; sebagian besar dilakukan compiler secara diam-diam berdasarkan aturan yang tidak kamu pilih. Mengetahui mana yang mana adalah perbedaan antara "kenapa rata-rataku selalu 3?" dan kode yang benar-benar melakukan apa yang tertulis.

Konversi Implisit

Setiap kali nilai dari satu tipe bertemu konteks yang mengharapkan tipe lain, C mengonversinya:

#include <stdio.h>

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

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

Konversi yang tidak mungkin menghilangkan informasi (int ke double, char ke int, short ke long) adalah konversi pelebaran (widening) dan selalu aman. Konversi ke arah sebaliknya adalah penyempitan (narrowing) dan bisa menghilangkan data: 3.9 di atas menjadi 3 tanpa peringatan apa pun, kecuali kamu memintanya dengan -Wconversion.

Konversi Aritmetika Biasa

Ketika sebuah operator biner punya operand dengan tipe berbeda, C mengonversinya ke tipe bersama sebelum mengerjakan operasinya. Urutannya, dari bawah ke atas:

1. Apa pun yang lebih kecil dari int (char, short, _Bool) dipromosikan menjadi int. Ini disebut integer promotion dan selalu terjadi lebih dulu.
2. Jika salah satu sisi bertipe long double, sisi lainnya menjadi long double.
3. Jika tidak, dan salah satunya double, yang lain menjadi double.
4. Jika tidak, dan salah satunya float, yang lain menjadi float.
5. Jika tidak, di antara tipe integer, yang peringkatnya lebih tinggi yang menang, dan jika peringkatnya sama, unsigned yang menang.

Aturan terakhir itulah yang menyebabkan bug sungguhan. Sisanya intuitif.

#include <stdio.h>

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

    /* a and b are promoted to int first, so 10000 fits fine. */
    printf("a * b as int = %d\n", a * b);

    /* But storing it back in a char narrows it again. */
    char product = a * b;
    printf("stored in char = %d\n", product);
    return 0;
}

Integer promotion adalah alasan aritmetika char tidak overflow seperti yang mungkin kamu duga, sekaligus alasan menyimpan hasilnya kembali ke char justru overflow.

Cast Eksplisit

Cast adalah tipe tujuan di dalam tanda kurung:

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

Cast berlaku untuk ekspresi yang tepat berada sesudahnya, dan ikatannya sangat kuat, lebih kuat daripada *, /, atau +.

#include <stdio.h>

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

    printf("no cast:        %f\n", (double)(total / count));  /* 3.0 */
    printf("cast first:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast both:      %f\n", (double)total / (double)count);
    return 0;
}

Baris pertama membagi sebagai integer (hasilnya 3) lalu mengonversi 3 menjadi 3.0, dan itu sudah terlambat. Baris kedua mengonversi total ke presisi yang cukup untuk 3.5 sebelum pembagian, sehingga operator / melihat sebuah double dan sebuah int, mempromosikan int-nya, dan melakukan pembagian floating-point.

Cukup lakukan cast pada satu operand. Konversi aritmetika biasa akan mengurus yang lain.

Memperbaiki Pembagian Integer

Inilah alasan paling umum untuk menulis cast di 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("sum = %d\n", sum);
    printf("wrong average: %f\n", (double)(sum / n));    /* 81.000000 - divided as ints, THEN converted */
    printf("right average: %f\n", (double)sum / n);      /* 81.200000 */

    /* Percentages have the same trap. */
    int passed = 3;
    printf("wrong pct: %d%%\n", passed / n * 100);            /* 0 percent */
    printf("right pct: %.1f%%\n", 100.0 * passed / n);        /* 60.0 percent */
    return 0;
}

Baris persentase itu memberi pelajaran: passed / n adalah 3 / 5, yang bernilai 0 sebagai integer, dan 0 * 100 adalah 0. Mengalikan sebelum membagi (100 * passed / n) memperbaikinya bahkan tanpa cast, karena 300 / 5 habis dibagi, tetapi itu hanya berhasil jika angka-angkanya kebetulan mendukung. Cast adalah perbaikan yang bisa diandalkan.

Dipotong, Bukan Dibulatkan

Melakukan cast nilai floating-point ke integer akan membuang pecahannya. Nilainya dipotong ke arah nol, bukan dibulatkan:

#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, not 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3, not -4 */

    /* Real rounding from 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;
}

Jika kamu membangun ini di mesinmu sendiri, ingat bahwa math.h butuh -lm saat linking di Linux.

Satu bahaya lagi: mengonversi nilai floating-point yang terlalu besar untuk tipe integernya adalah undefined behavior, bukan wraparound. (int)1e20 bisa menghasilkan apa saja. Cek rentangnya sebelum melakukan cast jika nilainya tidak berada dalam kendalimu.

char dan int

Di C, char adalah integer kecil yang berisi kode karakter. Mengonversi antara keduanya adalah pekerjaan sehari-hari:

#include <stdio.h>

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

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

    /* Digit character to its numeric value: */
    char digit = '7';
    int value = digit - '0';
    printf("the character '%c' as a number is %d\n", digit, value);

    /* Upper to lower, using the fixed 32-position gap in ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' adalah idiom standar untuk mengubah karakter digit menjadi nilainya, dan cara ini berhasil karena sepuluh karakter digit dijamin berurutan. Untuk huruf, pilih toupper() dan tolower() dari ctype.h daripada aritmetika + 32, karena selisih itu adalah fakta ASCII, bukan jaminan C.

Jebakan yang berkaitan: fungsi di ctype.h seperti isdigit dan toupper menerima int yang harus berupa EOF atau bisa direpresentasikan sebagai unsigned char. Mengirim char biasa yang bernilai negatif (mungkin terjadi, karena char biasa bisa bersifat signed) adalah perilaku tak terdefinisi. Lakukan cast: isdigit((unsigned char)c).

Jebakan Signed/Unsigned

Langkah 5 dari urutan konversi, unsigned menang saat peringkatnya sama, menghasilkan perbandingan paling mengejutkan di C:

#include <stdio.h>

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

    if (signed_val < unsigned_val) {
        printf("-1 is less than 1  (what you expect)\n");
    } else {
        printf("-1 is NOT less than 1  (what C actually says)\n");
    }

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

-1 dikonversi menjadi unsigned int, yang menafsirkan ulang pola bit-nya sebagai 4.294.967.295. Nilai itu lebih besar dari 1, jadi perbandingannya bernilai salah.

Konversi yang sama membuat perulangan berjalan selamanya:

/* BUG: i is unsigned, so i >= 0 is always true. When i is 0, i-- wraps. */
for (size_t i = n - 1; i >= 0; i--) { ... }

Dan membuat pengecekan panjang gagal:

/* BUG: strlen returns size_t (unsigned). If the string is shorter
   than 5, len - 5 wraps to a huge number and the test passes. */
if (strlen(s) - 5 > 0) { ... }

Tulis ulang menjadi if (strlen(s) > 5) dan pengurangannya tidak pernah terjadi.

Cara bertahannya: simpan jumlah dan indeks dalam satu jenis signedness dari awal sampai akhir, compile dengan -Wsign-compare (sudah termasuk di -Wextra), dan jika memang harus mencampurnya, lakukan cast eksplisit setelah memastikan nilainya tidak mungkin negatif.

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

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

    /* Safe: compare without subtracting. */
    if (len > 5) {
        printf("long\n");
    } else {
        printf("short: %zu characters\n", len);
    }

    /* Safe: cast to a signed type once the value is known to be small. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

Cast pada Pointer

Cast juga mengonversi antartipe pointer, dan di sini risikonya nyata, karena cast mengubah cara memori ditafsirkan, bukan byte-nya itu sendiri.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* View the bytes of an int through a char pointer. */
    unsigned char *bytes = (unsigned char *)&value;

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

Di mesin little-endian, kode ini mencetak 01 00 00 00. Memeriksa representasi objek lewat unsigned char * adalah salah satu dari sedikit cast pointer yang secara eksplisit direstui standar.

Sebagian besar cast pointer lainnya tidak direstui. Membaca int lewat float * melanggar aturan strict aliasing dan merupakan undefined behavior walaupun bisa di-compile; pakai memcpy untuk menafsirkan ulang byte.

Ada dua konvensi yang perlu diketahui. void * bisa dikonversi ke dan dari tipe pointer objek apa pun tanpa cast di C, dan itulah alasan kamu tidak perlu melakukan cast pada hasil malloc:

int *arr = malloc(n * sizeof *arr);        /* correct C */
int *arr = (int *)malloc(n * sizeof *arr); /* needless; hides a missing header */

Cast itu wajib di C++, dan karena itulah begitu banyak kode memakainya. Di C, cast itu bisa menyembunyikan kesalahan lupa meng-include <stdlib.h>.

Selain itu, printf("%p", ...) mengharapkan void *, jadi argumen pointer di sana memang benar-benar butuh cast: printf("%p", (void *)p).

Saat Cast Adalah Jawaban yang Salah

Cast membungkam compiler. Kadang compiler-nya justru benar.

long big = 5000000000L;
int  small = (int)big;    /* the cast hides real data loss */

Jika nilainya memang muat, cast itu mendokumentasikan bahwa kamu sudah mengeceknya. Jika mungkin tidak muat, cast itu mengubah sebuah peringatan menjadi jawaban salah yang diam-diam. Sebelum menulisnya, tanyakan apakah perbaikan yang tepat justru mengganti tipe sebuah variabel: double alih-alih int, size_t alih-alih int, long long alih-alih long. Cast adalah alat yang tepat terutama ketika dua tipe yang sama-sama benar harus bertemu untuk satu operasi, seperti pada (double)sum / count.