C++ Academy · Pelajaran

enum class Berscope

Enumerasi yang aman secara tipe

enum class Berscope adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C++ Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C++ Academy mencakup 4 pelajaran total.

Enumerasi Biasa Membocorkan Nama

enum gaya C klasik menaruh namanya ke dalam cakupan di sekitarnya dan secara diam-diam mengonversi ke int. Hal ini memudahkan terjadinya benturan nama dan perbandingan yang tidak disengaja.

enum class memperbaiki kedua masalah tersebut.
Nilai memiliki cakupan dan tipe yang kuat.

#include <iostream>
enum Color { Red, Green, Blue };
int main() {
    Color c = Green;
    int x = c; // implicit conversion to int
    std::cout << x << "\n";
}

Mendeklarasikan Enumerasi Bercakupan

Tambahkan kata kunci class (atau struct) untuk membuat enumerasi bercakupan. Sekarang setiap nilai harus disertai kualifikasi berupa nama enumerasinya.

#include <iostream>
enum class Color { Red, Green, Blue };
int main() {
    Color c = Color::Green;
    if (c == Color::Green) std::cout << "green\n";
}

Tidak Ada Konversi Implisit

Enumerasi bercakupan tidak akan secara implisit berubah menjadi int. Hal ini mencegah kesalahan ketika enumerasi tidak sengaja digunakan dalam operasi aritmetika.

Untuk mendapatkan angkanya, Anda harus melakukan konversi secara eksplisit.

#include <iostream>
enum class Color { Red, Green, Blue };
int main() {
    Color c = Color::Blue;
    int n = static_cast<int>(c); // explicit
    std::cout << n << "\n"; // prints 2
}

Tipe Dasar

Secara bawaan, tipe dasarnya adalah int, tetapi Anda dapat memilih tipe bilangan bulat yang lebih kecil atau spesifik untuk menghemat ruang atau menyesuaikannya dengan protokol.

#include <iostream>
#include <cstdint>
enum class Status : std::uint8_t { Ok = 0, Warn = 1, Error = 2 };
int main() {
    Status s = Status::Warn;
    std::cout << static_cast<int>(s) << "\n";
}

Nilai Khusus

Anda dapat menetapkan nilai eksplisit pada anggota enumerasi. Nilai yang mengikutinya akan melanjutkan penghitungan dari nilai eksplisit tersebut.

#include <iostream>
enum class Http { Ok = 200, NotFound = 404, ServerError = 500 };
int main() {
    Http h = Http::NotFound;
    std::cout << static_cast<int>(h) << "\n";
}

Menggunakan Enumerasi dalam switch

Enumerasi sangat berguna di dalam pernyataan switch. Mencantumkan setiap kasus memperjelas maksud dan memungkinkan kompiler memperingatkan Anda tentang kasus yang terlewat.

#include <iostream>
enum class Dir { North, East, South, West };
const char* name(Dir d) {
    switch (d) {
        case Dir::North: return "N";
        case Dir::East:  return "E";
        case Dir::South: return "S";
        case Dir::West:  return "W";
    }
    return "?";
}
int main() { std::cout << name(Dir::East) << "\n"; }

Enumerasi sebagai Argumen Fungsi

Meneruskan enumerasi bercakupan menyampaikan maksud jauh lebih baik daripada meneruskan int atau bool biasa. Kompiler memastikan bahwa hanya nilai enumerasi yang valid yang digunakan.

#include <iostream>
enum class Align { Left, Center, Right };
void render(const char* text, Align a) {
    std::cout << text << " aligned " << static_cast<int>(a) << "\n";
}
int main() { render("Hi", Align::Center); }

Membandingkan Nilai Enumerasi

Enumerasi bercakupan secara langsung mendukung == dan !=. Operator relasional (<, >) juga dapat digunakan karena nilainya memiliki urutan.

#include <iostream>
enum class Level { Low, Medium, High };
int main() {
    Level l = Level::High;
    std::cout << (l > Level::Low ? "above low\n" : "low\n");
}

Melakukan Iterasi secara Konseptual

Enumerasi tidak melakukan iterasi secara otomatis, tetapi pola yang umum adalah melakukan konversi melalui bilangan bulat dasarnya. Gunakan penanda batas seperti Count untuk mengetahui rentangnya.

#include <iostream>
enum class Coin { Penny, Nickel, Dime, Count };
int main() {
    for (int i = 0; i < static_cast<int>(Coin::Count); ++i)
        std::cout << i << " ";
    std::cout << "\n";
}

Mengapa Keamanan Tipe Penting

Dua enumerasi bercakupan yang tidak berkaitan tidak akan pernah tercampur secara tidak sengaja, meskipun keduanya memiliki nilai bernama None. Kompiler memperlakukannya sebagai tipe yang berbeda.

#include <iostream>
enum class Fruit { None, Apple };
enum class Tool  { None, Hammer };
int main() {
    Fruit f = Fruit::None;
    // Tool t = f; // would NOT compile
    std::cout << (f == Fruit::None) << "\n";
}

Kapan Menggunakan Enumerasi Biasa

Enumerasi biasa masih muncul dalam API warisan dan kode bendera bit, yang memanfaatkan kemudahan konversi implisit ke int. Untuk kode baru, utamakan enum class kecuali ada alasan khusus.

Pemeriksaan Singkat

Uji pemahaman Anda tentang enumerasi bercakupan.

Rangkuman

Anda telah mempelajari enumerasi bercakupan:

enum class membatasi cakupan nilai dan memblokir konversi implisit ke int.
Gunakan static_cast<int> untuk membaca angkanya.
Pilih tipe dasar dengan : type.
Utamakan enum class untuk kode yang aman terhadap tipe dan mendokumentasikan dirinya sendiri.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “enum class Berscope” gratis?

Ya — teks lengkap “enum class Berscope” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C++ Academy, upgrade ke CoddyKit PRO. Kursus C++ Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “enum class Berscope”?

Enumerasi yang aman secara tipe Kamu berlatih C++ Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C++ Academy?

Tidak diperlukan pengalaman sebelumnya. C++ Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “enum class Berscope” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy