Setiap tipe data menempati sejumlah byte tertentu, dan jumlah itu tidak ditentukan secara penuh oleh standar C++ — standar menetapkan ukuran minimal, sedangkan platform dan compiler menentukan sisanya. Program yang menyimpan jutaan elemen sangat sensitif terhadap ukuran tipe: salah memilih long long untuk data yang cukup dengan short berarti menggandakan konsumsi memori tanpa manfaat. C++ menyediakan operator sizeof untuk menanyakan ukuran pada saat kompilasi, dan header <limits> untuk menanyakan batas nilai setiap tipe. Pada Chapter ini kita mengukur sendiri tipe-tipe yang sudah kita pelajari sepanjang Section ini.

Operator sizeof #

sizeof adalah operator (bukan fungsi) yang menghasilkan jumlah byte dari sebuah tipe atau ekspresi pada saat kompilasi. Hasilnya bertipe std::size_t, tipe unsigned yang cukup untuk menampung ukuran objek apa pun. Satu jaminan penting dari standar: sizeof(char) selalu 1, dan tipe lain diukur sebagai kelipatannya.

cpp 
#include <iostream>

int main() {
    std::cout << "sizeof(bool)      = " << sizeof(bool) << " byte\n";
    std::cout << "sizeof(char)      = " << sizeof(char) << " byte\n";
    std::cout << "sizeof(short)     = " << sizeof(short) << " byte\n";
    std::cout << "sizeof(int)       = " << sizeof(int) << " byte\n";
    std::cout << "sizeof(long)      = " << sizeof(long) << " byte\n";
    std::cout << "sizeof(long long) = " << sizeof(long long) << " byte\n";
    std::cout << "sizeof(float)     = " << sizeof(float) << " byte\n";
    std::cout << "sizeof(double)    = " << sizeof(double) << " byte\n";

    int angka = 42;
    std::cout << "sizeof(angka)     = " << sizeof(angka) << " byte\n";

    return 0;
}

Output yang Dihasilkan:

text 
sizeof(bool)      = 1 byte
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(angka)     = 4 byte

Mari kita telaah apa yang terjadi pada baris-baris kode di atas:

  1. Baris 5-12 (sizeof(bool) dst.): setiap pemanggilan sizeof(tipe) diganti compiler dengan konstanta angka pada saat kompilasi — tidak ada perhitungan yang terjadi saat program berjalan.
  2. Baris 15 (sizeof(angka)): bentuk dengan ekspresi menghasilkan ukuran tipe variabel tersebut, yaitu sizeof(int) = 4 byte. Ekspresi di dalam sizeof tidak dievaluasi; angka 42 tidak dibaca, sehingga sizeof(angka = 99) pun tetap aman tanpa mengubah angka.
  3. Angka pada output: hasil ini berasal dari platform x86-64 Linux dengan GCC 14.2. Standar hanya menjamin char 1 byte dan long long minimal 64 bit, sehingga sizeof(long) bisa berbeda di Windows (4 byte pada beberapa konfigurasi) — angka yang Anda lihat boleh berbeda, dan prosa program sebaiknya tidak bergantung pada ukuran absolut.

Perhatikan bahwa sizeof pada tipe yang sama selalu menghasilkan nilai konstan di seluruh program. Karena itu compiler dapat menggunakan hasilnya untuk menyusun ukuran array statis dan alokasi memori tanpa biaya tambahan.

Batas Nilai dengan numeric_limits #

Header <limits> menyediakan class template std::numeric_limits<T> yang menampung sifat-sifat numerik tipe T. Member yang paling sering dipakai: min(), max(), lowest(), dan digits10. Semuanya didefinisikan sebagai static constexpr, sehingga nilainya juga tersedia pada saat kompilasi.

cpp 
#include <iostream>
#include <limits>

int main() {
    std::cout << "int: min = " << std::numeric_limits<int>::min() << "\n";
    std::cout << "int: max = " << std::numeric_limits<int>::max() << "\n";
    std::cout << "long long: max = " << std::numeric_limits<long long>::max() << "\n";

    std::cout << "double: max = " << std::numeric_limits<double>::max() << "\n";
    std::cout << "double: min (terkecil positif normal) = "
              << std::numeric_limits<double>::min() << "\n";
    std::cout << "double: digits10 = "
              << std::numeric_limits<double>::digits10 << "\n";

    return 0;
}

Output yang Dihasilkan:

text 
int: min = -2147483648
int: max = 2147483647
long long: max = 9223372036854775807
double: max = 1.79769e+308
double: min (terkecil positif normal) = 2.22507e-308
double: digits10 = 15

Mari kita telaah member-member yang dipakai:

  1. min() dan max(): batas nilai terkecil dan terbesar yang dapat disimpan tipe tersebut. Untuk int pada platform ini nilainya sesuai rentang 32 bit bertanda, yaitu sekitar ±2,1 miliar.
  2. long long: max: sekitar 9,2 kuintili (64 bit bertanda) — pilihan tepat ketika perhitungan berisiko melewati batas int.
  3. double: max: nilai berhingga terbesar (sekitar 1,8 × 10³⁰⁸). Nilai yang melewatinya menjadi infinit (inf), bukan wrap-around seperti integer.
  4. double: min(): untuk tipe floating-point, min() adalah nilai positif terkecil yang ternormalisasi — bukan angka paling negatif. Angka paling negatif diperoleh dari lowest(), yaitu -max().
  5. digits10: jumlah digit desimal yang dapat dicetak dan dibaca kembali tanpa kehilangan presisi — untuk double angkanya 15. Konsep ini menjadi dasar pembahasan floating-point pada Section Pemrograman Numerik.

numeric_limits juga menjawab pertanyaan umum lain: is_signed, is_integer, dan has_infinity mengembalikan true/false pada saat kompilasi, sehingga cocok dipasangkan dengan static_assert untuk memastikan asumsi kode Anda sejak awal. Dengan sizeof dan numeric_limits, kita kini dapat menulis kode yang menyatakan asumsi ukuran dan batas secara eksplisit — kebiasaan yang akan terus dipakai pada Section Operator ketika mulai menghitung batas aritmetika.