Enum trong C++: enum class và enum thường khác nhau thế nào

enum dùng để làm gì

Struct gom nhiều giá trị liên quan vào một đối tượng. enum (kiểu liệt kê) giải quyết một vấn đề khác: nó đặt tên cho một tập nhỏ, cố định các lựa chọn. Thay vì phải nhớ 0 là "đỏ", 1 là "xanh lá" và 2 là "xanh dương", bạn viết Color::Red và trình biên dịch giữ cho bạn không nhầm.

Dùng enum mỗi khi một biến chỉ có thể là một trong vài trạng thái có tên, như màu đèn giao thông, chất của lá bài hay trạng thái kết nối, giúp code tự giải thích và cho phép trình biên dịch bắt lỗi gõ sai hay thiếu trường hợp, điều mà số nguyên trần không bao giờ làm được.

Khai báo enum

C++ hiện đại có hai loại. Hãy bắt đầu với loại bạn nên dùng gần như mọi lúc: enum class có phạm vi (scoped). Bạn liệt kê các tên, và mỗi enumerator được truy cập qua tên của enum bằng :::

#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;
}

Để ý bạn viết Color::Green, không bao giờ viết Green trần. Bản thân các giá trị chỉ là nhãn: bạn so sánh, gán và truyền chúng đi, nhưng hiếm khi quan tâm con số bên dưới. Mặc định Red là 0, Green là 1 và Blue là 2, đếm tăng dần từ không.

enum thường và enum class

enum kiểu cũ, không có phạm vi (không có từ khóa class), thả các tên của nó thẳng vào phạm vi xung quanh và tự chuyển sang int. Nghe thì tiện, nhưng nó gây ra hai vấn đề thật sự:

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!
}

Vì các enumerator thường là tên toàn cục, hai enum có thể xung đột chỉ vì dùng chung một nhãn. Và vì chúng tự chuyển thành int, trình biên dịch vui vẻ so sánh giá trị của hai enum chẳng liên quan gì đến nhau. enum class có phạm vi sửa được cả hai: các tên nằm bên trong kiểu, và kiểu đó sẽ không âm thầm biến thành 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;
}

Quy tắc chung: mặc định dùng enum class. Chỉ quay về enum thường khi bạn thật sự cần chuyển đổi ngầm sang int, ví dụ các hằng số cờ kiểu C cũ.

Giá trị tùy chỉnh và kiểu nền

Bạn có thể gán số tường minh cho các enumerator. Những cái bạn bỏ trống sẽ tiếp tục đếm tăng từ cái trước, rất tiện cho những thứ như mã trạng thái HTTP hay cờ bit:

#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;
}

Mọi enum đều dựa trên một kiểu số nguyên, mặc định là int. Bạn có thể cố định nó vào một kiểu nhỏ hơn khi quan tâm đến kích thước, ví dụ lưu nhiều enum trong một cấu trúc được đóng gói chặt, hoặc khớp với một định dạng truyền dữ liệu:

#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;
}

Việc chọn kiểu nền cũng bảo đảm khoảng giá trị mà các giá trị của bạn phải nằm trong: một enum uint8_t không thể chứa giá trị lớn hơn 255.

Chuyển đổi giữa enum và int

enum class có phạm vi không bao giờ chuyển đổi ngầm, và đó chính là mục đích của nó. Khi bạn thật sự cần con số, để in ra, làm chỉ số mảng hay đọc từ tệp, hãy dùng static_cast. Chuyển từ enum sang int luôn an toàn:

#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;
}

Chuyển một int ngược lại thành enum mới là chiều nguy hiểm. Phép ép kiểu không kiểm tra con số đó có ứng với một enumerator thật hay không: nó sẽ trả cho bạn một giá trị về mặt kỹ thuật nằm ngoài tập tên của enum:

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

Nếu số nguyên đến từ dữ liệu người dùng nhập hoặc từ tệp, hãy tự kiểm tra khoảng giá trị trước khi ép kiểu, nếu không bạn sẽ tạo ra một giá trị mà không case nào xử lý, một nguồn undefined behavior khó thấy về sau.

Dùng enum với switch

Vì enum là "một trong một tập cố định", nó kết hợp hoàn hảo với switch. Khi bạn xử lý đủ mọi enumerator, nhiều trình biên dịch sẽ cảnh báo nếu sau này bạn thêm giá trị mới mà quên xử lý, một lớp an toàn miễn phí mà số nguyên thô không mang lại:

#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;
}

Một điểm dễ nhầm: không có cách nào có sẵn để in ra tên của một enumerator. cout << TrafficLight::Red sẽ không biên dịch được với enum có phạm vi, và ngay cả với enum thường thì nó cũng in ra con số chứ không phải "Red". Một switch nhỏ hoặc bảng tra cứu như ở trên là cách thường dùng để biến enum thành chuỗi dễ đọc.

Tiếp theo: ngoại lệ

Enum và struct giúp bạn mô tả dữ liệu trông như thế nào. Nhưng chương trình thật còn phải xử lý những lúc mọi thứ gặp trục trặc: một tệp không mở được, một con số không phân tích được, một giá trị nằm ngoài khoảng cho phép. C++ xử lý các nhánh lỗi đó bằng ngoại lệ (exception), và đó là nội dung trang tiếp theo.