Enum C++: Penjelasan enum class vs enum Biasa

Untuk Apa enum

Struct mengelompokkan beberapa nilai yang saling terkait ke dalam satu objek. enum menyelesaikan masalah yang berbeda: ia memberi nama pada sekumpulan kecil pilihan yang tetap. Daripada mengingat bahwa 0 berarti "merah", 1 berarti "hijau", dan 2 berarti "biru", kamu menulis Color::Red dan compiler menjagamu tetap konsisten.

Memakai enum setiap kali sebuah variabel hanya bisa berupa salah satu dari segelintir keadaan bernama, seperti warna lampu lalu lintas, jenis kartu, atau status koneksi, membuat kode menjelaskan dirinya sendiri dan membiarkan compiler menangkap salah ketik serta kasus yang terlewat, hal yang tidak akan pernah dilakukan bilangan bulat biasa.

Mendeklarasikan enum

C++ modern punya dua jenis. Mulailah dengan jenis yang hampir selalu sebaiknya kamu pakai: enum class yang ber-scope. Kamu menuliskan nama-namanya, dan setiap enumerator diakses lewat nama enum dengan :::

#include <iostream>
using namespace std;

enum class Color { Red, Green, Blue };

int main() {
    Color c = Color::Green;

    if (c == Color::Green) {
        cout << "It's green!" << endl;
    }

    return 0;
}

Perhatikan bahwa kamu menulis Color::Green, tidak pernah Green saja. Nilai-nilainya sendiri hanyalah label: kamu membandingkan, mengisi, dan meneruskannya, tetapi jarang peduli dengan angka di baliknya. Secara default Red bernilai 0, Green bernilai 1, dan Blue bernilai 2, dihitung naik mulai dari nol.

enum Biasa vs enum class

enum lama yang tidak ber-scope (tanpa kata kunci class) langsung menaruh nama-namanya ke scope di sekitarnya dan dikonversi ke int dengan sendirinya. Kedengarannya praktis, tetapi ini menimbulkan dua masalah nyata:

enum Color { Red, Green, Blue };
enum Fruit { Apple, Banana, Red };  // error: 'Red' already declared

enum Status { Active, Inactive };
int x = Active;          // compiles silently - is this what you meant?
if (Active == Banana) {  // compares unrelated enums via int - allowed!
}

Karena enumerator biasa adalah nama global, dua enum bisa bertabrakan hanya karena memakai label yang sama. Dan karena keduanya berubah menjadi int, compiler dengan senang hati membandingkan nilai dari enum yang sama sekali tidak berhubungan. enum class yang ber-scope memperbaiki keduanya: nama-namanya tinggal di dalam tipe, dan tipe itu tidak akan diam-diam berubah menjadi int:

#include <iostream>
using namespace std;

enum class Status { Active, Inactive };
enum class Fruit { Apple, Banana };

int main() {
    Status s = Status::Active;

    // s == Fruit::Apple;     // won't compile - different types, good
    // int x = s;             // won't compile - no implicit conversion

    cout << (s == Status::Active) << endl;  // prints 1 (true)
    return 0;
}

Patokannya: pakai enum class sebagai default. Kembali ke enum biasa hanya kalau kamu memang menginginkan konversi implisit ke int, misalnya untuk konstanta flag gaya C yang lama.

Nilai Sendiri dan Underlying Type

Kamu bisa memberi angka eksplisit pada enumerator. Yang tidak kamu beri nilai akan melanjutkan hitungan dari nilai sebelumnya, yang berguna untuk hal seperti kode status HTTP atau bit flag:

#include <iostream>
using namespace std;

enum class HttpStatus {
    Ok = 200,
    NotFound = 404,
    ServerError = 500
};

int main() {
    HttpStatus s = HttpStatus::NotFound;
    cout << "Status code: " << static_cast<int>(s) << endl;
    return 0;
}

Setiap enum didukung oleh sebuah tipe bilangan bulat, secara default int. Kamu bisa menetapkannya ke tipe yang lebih kecil kalau ukuran penting bagimu, misalnya saat menyimpan banyak enum di struktur yang padat atau saat harus cocok dengan format data tertentu:

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

enum class Direction : uint8_t { North, East, South, West };

int main() {
    cout << "size: " << sizeof(Direction) << " byte" << endl;  // 1
    return 0;
}

Memilih underlying type juga menjamin rentang yang harus dipenuhi nilai-nilaimu: enum uint8_t tidak bisa menyimpan nilai di atas 255.

Konversi antara enum dan int

enum class yang ber-scope tidak pernah dikonversi secara implisit, dan memang itulah intinya. Saat kamu benar-benar butuh angkanya, misalnya untuk mencetaknya, menjadikannya indeks array, atau membacanya dari file, pakai static_cast. Konversi dari enum ke int selalu aman:

#include <iostream>
using namespace std;

enum class Suit { Hearts, Diamonds, Clubs, Spades };

int main() {
    Suit s = Suit::Clubs;
    int index = static_cast<int>(s);   // 2
    cout << "index: " << index << endl;
    return 0;
}

Mengonversi int kembali ke enum adalah arah yang berbahaya. Cast tidak mengecek bahwa angkanya sesuai dengan enumerator yang benar-benar ada; ia akan memberimu nilai yang secara teknis berada di luar kumpulan nama enum itu:

Suit s = static_cast<Suit>(2);   // fine - that's Clubs
Suit bad = static_cast<Suit>(99); // compiles, but 99 is not a valid Suit
// using `bad` in a switch or as an array index is a lurking bug

Kalau bilangan bulatnya berasal dari input pengguna atau file, validasi rentangnya sendiri sebelum melakukan cast. Kalau tidak, kamu akan menciptakan nilai yang tidak pernah ditangani case mana pun, sumber halus undefined behavior di kemudian hari.

Memakai enum dengan switch

Karena enum berarti "salah satu dari kumpulan tetap", ia sangat cocok dipasangkan dengan switch. Kalau kamu menangani setiap enumerator, banyak compiler akan memperingatkanmu saat nanti kamu menambah nilai baru dan lupa menanganinya. Ini keamanan gratis yang tidak kamu dapat dari bilangan bulat mentah:

#include <iostream>
using namespace std;

enum class TrafficLight { Red, Yellow, Green };

void describe(TrafficLight light) {
    switch (light) {
        case TrafficLight::Red:
            cout << "Stop" << endl;
            break;
        case TrafficLight::Yellow:
            cout << "Slow down" << endl;
            break;
        case TrafficLight::Green:
            cout << "Go" << endl;
            break;
    }
}

int main() {
    describe(TrafficLight::Yellow);
    return 0;
}

Satu jebakan: tidak ada cara bawaan untuk mencetak nama sebuah enumerator. cout << TrafficLight::Red tidak akan bisa dikompilasi untuk enum yang ber-scope, dan bahkan untuk enum biasa yang dicetak adalah angkanya, bukan "Red". switch kecil atau tabel pencarian seperti contoh di atas adalah cara yang biasa dipakai untuk mengubah enum menjadi string yang bisa dibaca manusia.

Berikutnya: Exception

Enum dan struct membantumu memodelkan seperti apa datamu. Namun program sungguhan juga harus menghadapi saat-saat ketika sesuatu salah: file yang tidak mau terbuka, angka yang tidak bisa di-parse, nilai yang di luar rentang. C++ menangani jalur kegagalan seperti itu dengan exception, dan itulah topik halaman berikutnya.