Tipe Data di C: int, float, char, double, dan Lainnya

Setiap variabel di C punya tipe, dipilih saat dideklarasikan dan tetap sepanjang umurnya. Tipe menentukan tiga hal: berapa byte yang dipakai variabel itu, bagaimana byte-byte itu ditafsirkan, dan operasi apa yang masuk akal untuknya.

Daftar tipe di C pendek. Kerumitannya ada di modifier.

Empat Tipe Dasar

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* one character / one byte */
    int   count   = 42;         /* whole number */
    float ratio   = 3.14f;      /* decimal, single precision */
    double precise = 3.141592653589793;  /* decimal, double precision */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

• char menyimpan satu byte. Dipakai untuk satu karakter ('A'), untuk byte-byte sebuah string, dan kadang sebagai integer yang sangat kecil.
• int adalah tipe bilangan bulat andalan. Counter loop, ukuran, ID.
• float dan double menyimpan bilangan real. double punya presisi kira-kira dua kali lipat.
• void dalam arti tertentu adalah tipe keempat, tetapi artinya "tidak ada nilai": kamu tidak bisa mendeklarasikan variabel void, hanya memakainya sebagai tipe kembalian fungsi, daftar parameter kosong, atau pointer tanpa tipe.

Perhatikan akhiran f pada 3.14f. Tanpa akhiran itu, literalnya bertipe double, dan meng-assign-nya ke float diam-diam mengurangi presisi. Sebagian compiler memberi peringatan untuk ini.

Modifier: short, long, unsigned

Tipe integer dasar dilengkapi modifier yang mengubah ukuran atau tandanya.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

Setiap tipe integer butuh format specifier-nya sendiri: %hd untuk short, %d untuk int, %ld untuk long, %lld untuk long long, %u untuk unsigned. Memakai yang salah adalah undefined behavior, bukan sekadar kesalahan pembulatan.

unsigned menghilangkan bit tanda dan menggandakan rentang positifnya. unsigned int menyimpan 0 sampai sekitar 4,3 miliar, alih-alih -2,1 sampai +2,1 miliar. Ini pilihan yang tepat untuk hal yang memang tidak mungkin negatif, seperti ukuran, jumlah byte, dan pola bit, tetapi menjadi jebakan untuk apa pun yang mungkin dikurangi sampai di bawah nol.

signed adalah default untuk int, short, long, dan long long, jadi kamu hampir tidak pernah menuliskannya. Satu-satunya tempat ini penting adalah char: apakah char biasa bersifat signed atau unsigned ditentukan oleh implementasi, jadi tulis signed char atau unsigned char kalau tandanya penting.

Ukuran: Apa yang Sebenarnya Kamu Dapat

Standar C menetapkan ukuran minimum, bukan ukuran pasti. Di mesin Linux, macOS, atau Windows 64-bit modern mana pun, kamu akan melihat ini:

Baris long adalah yang sering menjebak: ukurannya 8 byte di Linux dan macOS, tetapi 4 byte di Windows 64-bit. Kode yang menganggap long bisa menampung nilai 64-bit tidak portabel. Gunakan long long, atau tipe dengan lebar pasti dari stdint.h (int32_t, uint64_t) kalau ukurannya memang bagian dari kebutuhan.

sizeof: Tanyakan ke Compiler

Jangan pernah menebak ukuran, ukur saja:

#include <stdio.h>

int main(void) {
    printf("char:        %zu byte(s)\n", sizeof(char));
    printf("short:       %zu bytes\n", sizeof(short));
    printf("int:         %zu bytes\n", sizeof(int));
    printf("long:        %zu bytes\n", sizeof(long));
    printf("long long:   %zu bytes\n", sizeof(long long));
    printf("float:       %zu bytes\n", sizeof(float));
    printf("double:      %zu bytes\n", sizeof(double));
    printf("a pointer:   %zu bytes\n", sizeof(int *));
    return 0;
}

sizeof adalah operator, bukan fungsi, dan dievaluasi saat kompilasi. Hasilnya bertipe size_t, yang dicetak dengan %zu.

sizeof(char) dijamin tepat 1, karena itulah definisi byte di C. Semua tipe lain diukur relatif terhadapnya.

limits.h dan float.h

Rentang pasti untuk compiler-mu tersedia sebagai konstanta bernama:

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d bits per byte\n", CHAR_BIT);
    printf("FLT_DIG      = %d decimal digits\n", FLT_DIG);
    printf("DBL_DIG      = %d decimal digits\n", DBL_DIG);
    return 0;
}

Inilah nilai yang dipakai sebagai pembanding saat kamu perlu tahu apakah sebuah operasi akan overflow. Memeriksa if (a > INT_MAX - b) sebelum menghitung a + b adalah cara mendeteksi overflow sebelum terjadi. Itu penting, karena kamu tidak bisa mendeteksi signed overflow sesudahnya.

Integer Overflow

Apa yang terjadi saat sebuah nilai melampaui rentang tipenya sepenuhnya bergantung pada tandanya.

Unsigned overflow terdefinisi: nilainya melingkar modulo 2^N.

#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* guaranteed to be 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* wraps to UINT_MAX */
    return 0;
}

Kasus kedua itu adalah sumber bug yang nyata. Loop seperti for (unsigned i = n - 1; i >= 0; i--) tidak pernah berhenti, karena nilai unsigned selalu >= 0.

Signed overflow adalah undefined behavior. Bukan "melingkar", melainkan tidak terdefinisi. Compiler boleh menganggap hal itu tidak pernah terjadi dan melakukan optimasi berdasarkan anggapan tersebut, yang berarti pemeriksaan overflow yang ditulis setelah kejadian bisa dihapus:

int sum = a + b;
if (sum < a) { /* the compiler may remove this entirely */ }

Periksa sebelumnya, dengan memakai batasnya:

if (b > 0 && a > INT_MAX - b) {
    /* a + b would overflow - handle it */
}

Presisi Floating-Point

float dan double menyimpan angka dalam biner, dan sebagian besar pecahan desimal tidak punya bentuk biner yang pasti, sama seperti 1/3 tidak punya bentuk desimal yang pasti.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("Is it 0.3? %s\n", (sum == 0.3) ? "yes" : "no");

    /* The right way: compare within a tolerance. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Close enough? %s\n", (diff < 1e-9) ? "yes" : "no");
    return 0;
}

Aturan yang mengikutinya: jangan pernah membandingkan nilai floating-point dengan ==. Bandingkan selisih mutlaknya dengan toleransi kecil.

Dan jangan pernah memakai floating-point untuk uang. Simpan sen sebagai integer; long long berisi sen itu pasti, sedangkan double berisi dolar tidak.

Memilih Tipe

Daftar keputusan singkat yang mencakup sebagian besar kode:

• Bilangan bulat: int, kecuali ada alasan lain. Inilah tipe yang paling efisien ditangani CPU dan tipe yang menjadi dasar semua aturan aritmetika.
• Apa pun yang lebih besar dari 2 miliar: long long, atau int64_t dari stdint.h.
• Ukuran, panjang, indeks array dari sizeof atau strlen: size_t. Tipe ini unsigned dan dijamin cukup besar untuk objek apa pun.
• Desimal: double. Gunakan float hanya untuk menghemat setengah memori di array besar atau di hardware embedded tanpa unit presisi ganda.
• Satu karakter dan byte mentah: char untuk teks, unsigned char untuk data biner.
• True/false: bool dari stdbool.h; lihat boolean di C.
• Lebar bit pasti (format file, protokol jaringan, register hardware): stdint.h, yaitu uint8_t, int16_t, uint32_t, dan seterusnya.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint8_t  flags = 0xFF;          /* exactly 8 bits, unsigned */
    int32_t  offset = -100000;      /* exactly 32 bits, signed */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu bytes\n", (unsigned long long)file_size);
    return 0;
}

Mencampur Tipe

Saat kamu menggabungkan dua tipe berbeda dalam satu ekspresi, C mengonversinya diam-diam sebelum melakukan aritmetika. Biasanya ini membantu, tetapi sesekali berakibat fatal:

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  as ints   = %d\n", a / b);        /* 3, not 3.5 */
    printf("7 / 2  with 2.0  = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "yes" : "no");  /* surprising */
    return 0;
}

Yang pertama adalah pembagian integer: kedua operand bertipe int, jadi hasilnya int dan pecahannya dibuang. Yang ketiga lebih buruk: membandingkan nilai signed dengan nilai unsigned mengonversi yang signed menjadi unsigned, sehingga -1 berubah menjadi bilangan positif yang sangat besar.

Aturan konversi itu, dan cara mengendalikannya dengan cast eksplisit, dibahas di type casting di C.