Operator sizeof adalah alat untuk mengetahui ukuran memori sebuah tipe atau objek dalam satuan byte. Walaupun terlihat sederhana, operator ini sangat penting karena ukuran tipe di C bergantung pada arsitektur dan compiler—int bisa berukuran 2 byte pada sistem embedded lama, 4 byte pada kebanyakan sistem modern, atau 8 byte pada sistem khusus. Pada Chapter ini kita akan menelaah cara kerja sizeof, perbedaan antara sizeof(tipe) dan sizeof ekspresi, perilaku khususnya pada array dan pointer, serta idiom klasik sizeof arr / sizeof arr[0] untuk menghitung jumlah elemen array. Kita juga akan melihat bahwa sizeof dievaluasi saat kompilasi (kecuali pada variable-length array C99), sehingga tidak menimbulkan biaya runtime.

Sintaks dan Cara Kerja #

Operator sizeof memiliki dua bentuk:

  • sizeof (tipe) — tipe harus dalam tanda kurung.
  • sizeof ekspresi — tanda kurung opsional (tetapi sering dipakai untuk kejelasan).

Hasil sizeof bertipe size_t yang didefinisikan di <stddef.h> (termasuk otomatis melalui <stdio.h>). size_t adalah tipe unsigned yang cukup besar untuk menampung ukuran objek manapun di memori. Untuk mencetak size_t dengan printf, gunakan format specifier %zu.

c 
#include <stdio.h>

int main(void) {
    /* sizeof pada tipe dasar */
    printf("sizeof(char)      = %zu byte\n", sizeof(char));
    printf("sizeof(short)     = %zu byte\n", sizeof(short));
    printf("sizeof(int)       = %zu byte\n", sizeof(int));
    printf("sizeof(long)      = %zu byte\n", sizeof(long));
    printf("sizeof(long long) = %zu byte\n", sizeof(long long));
    printf("sizeof(float)     = %zu byte\n", sizeof(float));
    printf("sizeof(double)    = %zu byte\n", sizeof(double));
    printf("sizeof(void *)    = %zu byte\n", sizeof(void *));
    return 0;
}

Output yang Dihasilkan:

text 
sizeof(char)      = 1 byte
sizeof(short)     = 2 byte
sizeof(int)       = 4 byte
sizeof(long)      = 8 byte
sizeof(long long) = 8 byte
sizeof(float)     = 4 byte
sizeof(double)    = 8 byte
sizeof(void *)    = 8 byte

Mari kita telaah baris-baris kode di atas:

  1. Baris 5 (sizeof(char)): standar C menjamin sizeof(char) == 1 tanpa bergantung pada platform.
  2. Baris 7 (sizeof(int)): hasil 4 adalah ukuran umum int pada Linux x86_64; bisa berbeda pada platform lain.
  3. Baris 8-9 (sizeof(long) dan sizeof(long long)): pada Linux x86_64 (LP64), keduanya 8; pada Windows x86_64 (LLP64), sizeof(long) == 4 sedangkan sizeof(long long) == 8. Perbedaan ini menjadi sumber bug klasik saat menulis kode lintas-platform.
  4. Baris 11 (sizeof(void *)): ukuran pointer di sistem 64-bit adalah 8 byte; di sistem 32-bit adalah 4 byte.

sizeof pada Variabel, Array, dan Pointer #

Saat sizeof diterapkan pada variabel, tanda kurung bersifat opsional: sizeof nilai dan sizeof(nilai) keduanya valid. Yang menarik adalah perbedaan perilaku sizeof pada array versus pointer—sizeof array mengembalikan total byte yang ditempati array, sedangkan sizeof pointer mengembalikan ukuran pointer itu sendiri (biasanya 4 atau 8 byte), bukan ukuran data yang ditunjuk.

c 
#include <stdio.h>

int main(void) {
    int nilai = 42;
    double harga = 17500.5;
    char nama[] = "Budi Santoso";

    /* sizeof pada ekspresi/variabel */
    printf("sizeof(nilai)   = %zu byte\n", sizeof nilai);
    printf("sizeof(harga)   = %zu byte\n", sizeof harga);
    printf("sizeof(nama)    = %zu byte  (string literal)\n", sizeof nama);

    /* sizeof pada array vs pointer */
    int arr[10];
    int *p = arr;
    printf("\nsizeof(arr)     = %zu byte  (10 * 4 = 40)\n", sizeof arr);
    printf("sizeof(p)       = %zu byte  (ukuran pointer)\n", sizeof p);
    printf("Jumlah elemen   = %zu\n", sizeof arr / sizeof arr[0]);
    return 0;
}

Output yang Dihasilkan:

text 
sizeof(nilai)   = 4 byte
sizeof(harga)   = 8 byte
sizeof(nama)    = 13 byte  (string literal)

sizeof(arr)     = 40 byte  (10 * 4 = 40)
sizeof(p)       = 8 byte  (ukuran pointer)
Jumlah elemen   = 10

Pada baris ke-9, sizeof nama mengembalikan 13 karena array nama menyimpan 12 karakter ditambah terminator null '\0'. Pada baris ke-15, sizeof arr mengembalikan total ukuran array 10 * 4 = 40 byte. Pada baris ke-17, ekspresi sizeof arr / sizeof arr[0] menghitung jumlah elemen array dengan membagi total ukuran dengan ukuran satu elemen—ini adalah idiom klasik C yang harus diingat. Perhatikan bahwa ketika array dilewatkan ke fungsi sebagai parameter, array meluruh menjadi pointer, sehingga sizeof di dalam fungsi tersebut tidak lagi mengembalikan ukuran array asli.

sizeof pada Struct dan Padding #

Saat diterapkan pada struct, sizeof mengembalikan total ukuran termasuk padding—byte-byte kosong yang ditambahkan compiler untuk menjaga alignment memori agar akses ke anggota struct tetap efisien. Inilah sebabnya jumlah sizeof setiap anggota sering kali lebih kecil dari sizeof(struct ...) secara keseluruhan.

c 
#include <stdio.h>

struct Mahasiswa {
    char nama[32];
    int umur;
    double ipk;
};

int main(void) {
    /* sizeof pada struct */
    struct Mahasiswa mhs;
    printf("sizeof(struct Mahasiswa) = %zu byte\n", sizeof(struct Mahasiswa));
    printf("sizeof(mhs)              = %zu byte\n", sizeof mhs);

    /* sizeof pada anggota struct */
    printf("offset & padding:\n");
    printf("  sizeof(mhs.nama) = %zu\n", sizeof mhs.nama);
    printf("  sizeof(mhs.umur) = %zu\n", sizeof mhs.umur);
    printf("  sizeof(mhs.ipk)  = %zu\n", sizeof mhs.ipk);
    printf("  total anggota    = %zu (tanpa padding)\n",
           sizeof mhs.nama + sizeof mhs.umur + sizeof mhs.ipk);
    return 0;
}

Output yang Dihasilkan:

text 
sizeof(struct Mahasiswa) = 48 byte
sizeof(mhs)              = 48 byte
offset & padding:
  sizeof(mhs.nama) = 32
  sizeof(mhs.umur) = 4
  sizeof(mhs.ipk)  = 8
  total anggota    = 44 (tanpa padding)

Pada output di atas, total ukuran anggota struct Mahasiswa adalah 32 + 4 + 8 = 44 byte, namun sizeof(struct Mahasiswa) mengembalikan 48 byte. Selisih 4 byte berasal dari padding yang ditambahkan compiler setelah umur (int 4 byte) agar anggota berikutnya ipk (double 8 byte) berada di alamat yang kelipatan 8. Tata letak padding ini bergantung pada ABI platform—aturan alignment berbeda antara x86, ARM, dan lainnya.

sizeof Dievaluasi Saat Kompilasi #

Operator sizeof pada tipe dan ekspresi non-VLA dievaluasi saat kompilasi—hasilnya berupa konstanta yang disisipkan langsung ke dalam kode mesin. Hal ini berarti sizeof tidak menimbulkan biaya runtime dan tidak mengevaluasi ekspresi operandnya (jika sizeof diterapkan pada a + b, ekspresi a + b tidak benar-benar dihitung). Pengecualian adalah variable-length array (VLA) yang diperkenalkan C99—sizeof pada VLA dievaluasi saat runtime.

Dengan operator sizeof kita memiliki alat aman untuk menulis kode yang sadar ukuran tipe dan tidak bergantung pada asumsi kaku. Pada Chapter berikutnya kita akan meninjau operator koma yang memungkinkan kita mengevaluasi beberapa ekspresi secara berurutan.