Tipe Data C++: int, double, char, bool, dan Lainnya

Kenapa Tipe Penting di C++

Saat kamu mendeklarasikan nilai dengan tipe eksplisit seperti int age = 30;, tipe itu bukan sekadar label. Ia memberi tahu compiler berapa byte yang perlu disediakan, cara menafsirkan byte-byte itu, dan operasi apa saja yang sah. Salah memilih tipe bisa membuatmu diam-diam kehilangan presisi, mengalami overflow, atau memicu undefined behavior.

C++ mengelompokkan tipe bawaannya ke dalam beberapa keluarga: bilangan bulat, bilangan floating-point, tipe karakter, dan boolean. Mari kita lihat masing-masing, lalu aturan-aturan yang sering menjebak.

Tipe-Tipe Dasar

Berikut satu contoh dari setiap tipe inti dalam satu program. Perhatikan sufiks literalnya (L, f, u) dan tanda kutip tunggal pada char:

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // whole number, usually 32-bit
    long long big = 9000000000LL; // wider integer, the LL suffix
    double price = 19.99;       // 64-bit decimal (the default for decimals)
    float  ratio = 0.5f;        // 32-bit decimal - note the f
    char   grade = 'A';         // a single character, single quotes
    bool   passed = true;       // only true or false

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // bool prints as 1 / 0
}

Secara default bool dicetak sebagai 1 atau 0, bukan true/false. char memakai tanda kutip tunggal: 'A' adalah satu karakter, sedangkan "A" (tanda kutip ganda) adalah string literal, tipe yang sama sekali berbeda. Dua kesalahan itu sangat umum di awal belajar.

Ukurannya Tidak Tetap

Inilah kejutan terbesar bagi yang datang dari bahasa seperti Java. Standar C++ hanya menjamin ukuran minimum dan urutan relatifnya (short ≤ int ≤ long ≤ long long). Ukuran sebenarnya bergantung pada compiler dan platform-mu. Selalu cek dengan sizeof:

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // always 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

Di build Linux 64-bit yang umum, kamu akan melihat int = 4, long = 8. Namun di Windows 64-bit, long hanya 4 byte. Celah portabilitas itulah alasan kamu sebaiknya tidak menulis kode yang menganggap long selalu 64-bit.

Kalau kamu butuh lebar yang pasti, pakai tipe bilangan bulat fixed-width di <cstdint>:

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    int8_t   a = -120;          // exactly 8 bits, signed
    uint16_t b = 65000;         // exactly 16 bits, unsigned
    int32_t  c = 2000000000;    // exactly 32 bits
    int64_t  d = 9000000000LL;  // exactly 64 bits, every platform

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

Pakai int32_t/int64_t untuk format file, protokol jaringan, atau apa pun yang harus berperilaku sama di semua mesin. Perhatikan cast (int)a: mengirim tipe 8-bit ke stream akan mencetaknya sebagai karakter, bukan angka, jadi lakukan cast terlebih dulu.

Signed vs Unsigned

Setiap tipe bilangan bulat punya dua varian. Tipe signed bisa menyimpan bilangan negatif; tipe unsigned tidak bisa, dan sebagai gantinya punya batas atas positif yang lebih tinggi. int biasa bersifat signed secara default.

#include <iostream>
#include <climits>
using namespace std;

int main() {
    unsigned int u = 0;
    u = u - 1;          // does NOT become -1
    cout << u << "\n";  // wraps to 4294967295 (the max unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

Mengurangi 0 yang unsigned akan berputar balik (wrap around) menjadi bilangan positif yang sangat besar, bukan menjadi negatif. Ini terus-menerus menjebak orang, terutama dengan size_t (tipe unsigned) yang dikembalikan oleh .size():

vector<int> v = {1, 2, 3};
// DANGER: v.size() is unsigned. If v is empty, v.size() - 1 wraps
// to a gigantic number and the loop runs nearly forever.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

Utamakan i < v.size() (jangan pernah <= size() - 1), atau hindari masalahnya sama sekali dengan range-based for loop.

Integer Overflow Adalah Undefined Behavior

Berbeda dengan wraparound pada unsigned (yang perilakunya terdefinisi dengan baik), overflow pada bilangan bulat signed adalah undefined behavior di C++. Compiler boleh melakukan apa saja: mengembalikan nilai sampah, menghapus pengecekannya lewat optimasi, atau membuat program crash:

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // UNDEFINED BEHAVIOR - often wraps negative

    long long safe = (long long)maxInt + 1; // promote before adding
    cout << safe << "\n";            // 2147483648, correct
}

Solusinya sama dengan jebakan overflow di bahasa mana pun: lakukan aritmetikanya di tipe yang lebih lebar. Cast salah satu operan ke long long sebelum +, supaya penjumlahannya terjadi dalam 64 bit. Melakukan cast pada hasilnya sesudahnya sudah terlambat, karena overflow-nya sudah terjadi.

Memilih Tipe yang Tepat

Untuk sebagian besar kode, pilihan default sudah cukup: int untuk bilangan bulat, double untuk bilangan desimal. Pakai yang lain hanya kalau kamu punya alasan.

Ada beberapa jebakan yang perlu diingat. float hanya punya sekitar 7 digit desimal yang signifikan, jadi 0.1f + 0.2f tidak persis 0.3. Utamakan double kecuali kamu benar-benar perlu menghemat memori. Selain itu, char bisa signed atau unsigned tergantung platform-nya, jadi kalau kamu melakukan aritmetika pada byte mentah, tulis signed char atau unsigned char secara eksplisit.

Berikutnya: Kata Kunci auto

Menulis tipe setiap kali lama-lama melelahkan, dan kadang tipenya panjang atau sulit disebutkan. C++ membiarkan compiler menyimpulkannya untukmu dengan kata kunci auto: auto x = 42; membuat x menjadi int, dan auto it = v.begin(); menghemat kamu dari mengetik tipe iterator yang panjang. Halaman berikutnya membahas kapan auto membuat kode lebih jelas dan kapan ia menyembunyikan terlalu banyak.