không gian tên cho các loại enum - các phương pháp hay nhất

Thông thường, người ta cần nhiều kiểu liệt kê cùng nhau. Đôi khi, người ta có một cuộc đụng độ tên tuổi. Có hai giải pháp cho vấn đề này: sử dụng không gian tên hoặc sử dụng tên phần tử enum 'lớn hơn'. Tuy nhiên, giải pháp không gian tên có hai cách triển khai khả thi: một lớp giả với các enum lồng nhau hoặc một không gian tên hoàn chỉnh.

Tôi đang tìm kiếm ưu và nhược điểm của cả ba cách tiếp cận.

Thí dụ:

// oft seen hand-crafted name clash solution
enum eColors { cRed, cColorBlue, cGreen, cYellow, cColorsEnd };
enum eFeelings { cAngry, cFeelingBlue, cHappy, cFeelingsEnd };
void setPenColor( const eColors c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cColorBlue: //...
        //...
    }
 }


// (ab)using a class as a namespace
class Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
class Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
 }


 // a real namespace?
 namespace Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
 namespace Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
 void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
  }

Câu trả lời gốc C ++ 03:

Các lợi ích từ một namespace(hơn một class) là bạn có thể sử dụng usingtờ khai khi bạn muốn.

Các vấn đề với việc sử dụng một namespacelà không gian tên có thể được mở rộng ở những nơi khác trong các mã. Trong một dự án lớn, bạn sẽ không được đảm bảo rằng hai môi trường khác nhau đều không nghĩ rằng chúng được gọi làeFeelings

Đối với mã trông đơn giản hơn, tôi sử dụng a struct, vì bạn có lẽ muốn nội dung được công khai.

Nếu bạn đang thực hiện bất kỳ phương pháp nào trong số này, bạn đã đi trước đường cong và có thể không cần xem xét kỹ lưỡng điều này thêm.

Lời khuyên mới hơn, C ++ 11:

Nếu bạn đang sử dụng C ++ 11 trở lên, enum classsẽ ngầm định phạm vi các giá trị enum trong tên của enum.

Với enum classbạn, bạn sẽ mất các chuyển đổi và so sánh ngầm định với các loại số nguyên, nhưng trong thực tế, điều đó có thể giúp bạn phát hiện ra mã không rõ ràng hoặc có lỗi.

FYI Trong C ++ 0x có một cú pháp mới cho các trường hợp như những gì bạn đã đề cập (xem trang wiki C ++ 0x )

enum class eColors { ... };
enum class eFeelings { ... };

Tôi đã kết hợp các câu trả lời trước với một cái gì đó như thế này: (CHỈNH SỬA: Điều này chỉ hữu ích cho trước C ++ 11. Nếu bạn đang sử dụng C ++ 11, hãy sử dụng enum class)

Tôi có một tệp tiêu đề lớn chứa tất cả các enum dự án của tôi, bởi vì các enum này được chia sẻ giữa các lớp worker và không có ý nghĩa gì khi đặt các enums trong chính các lớp worker.

Các hàm này structtránh public: cú pháp sugar và typedefcho phép bạn thực sự khai báo các biến của các enum này trong các lớp worker khác.

Tôi không nghĩ rằng việc sử dụng một không gian tên sẽ giúp ích gì cả. Có lẽ điều này là do tôi là một lập trình viên C #, và ở đó bạn phải sử dụng tên kiểu enum khi tham chiếu các giá trị, vì vậy tôi đã quen với nó.

    struct KeySource {
        typedef enum { 
            None, 
            Efuse, 
            Bbram
        } Type;
    };

    struct Checksum {
        typedef enum {
            None =0,
            MD5 = 1,
            SHA1 = 2,
            SHA2 = 3
        } Type;
    };

    struct Encryption {
        typedef enum {
            Undetermined,
            None,
            AES
        } Type;
    };

    struct File {
        typedef enum {
            Unknown = 0,
            MCS,
            MEM,
            BIN,
            HEX
        } Type;
    };

...

class Worker {
    File::Type fileType;
    void DoIt() {
       switch(fileType) {
       case File::MCS: ... ;
       case File::MEM: ... ;
       case File::HEX: ... ;
    }
}

Tôi chắc chắn sẽ tránh sử dụng một lớp học cho việc này; sử dụng không gian tên để thay thế. Câu hỏi xoay quanh việc nên sử dụng không gian tên hay sử dụng id duy nhất cho các giá trị enum. Cá nhân tôi sử dụng một không gian tên để id của tôi có thể ngắn hơn và hy vọng sẽ dễ hiểu hơn. Sau đó, mã ứng dụng có thể sử dụng chỉ thị 'sử dụng không gian tên' và làm cho mọi thứ dễ đọc hơn.

Từ ví dụ của bạn ở trên:

using namespace Colors;

void setPenColor( const e c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cBlue: //...
        //...
    }
}

Sự khác biệt giữa việc sử dụng một lớp hoặc một không gian tên là lớp không thể được mở lại như một không gian tên có thể. Điều này tránh khả năng không gian tên có thể bị lạm dụng trong tương lai, nhưng cũng có một vấn đề là bạn cũng không thể thêm vào tập hợp các kiểu liệt kê.

Một lợi ích có thể có khi sử dụng một lớp, là chúng có thể được sử dụng làm đối số kiểu mẫu, điều này không đúng với không gian tên:

class Colors {
public:
  enum TYPE {
    Red,
    Green,
    Blue
  };
};

template <typename T> void foo (T t) {
  typedef typename T::TYPE EnumType;
  // ...
}

Cá nhân tôi không phải là người thích sử dụng và tôi thích những cái tên đủ tiêu chuẩn hơn, vì vậy tôi không thực sự coi đó là một điểm cộng cho không gian tên. Tuy nhiên, đây có lẽ không phải là quyết định quan trọng nhất mà bạn sẽ thực hiện trong dự án của mình!

Lợi thế của việc sử dụng một lớp là bạn có thể xây dựng một lớp chính thức bên trên nó.

#include <cassert>

class Color
{
public:
    typedef enum
    {
        Red,
        Blue,
        Green,
        Yellow
    } enum_type;

private:
    enum_type _val;

public:
    Color(enum_type val = Blue)
        : _val(val)
    {
        assert(val <= Yellow);
    }

    operator enum_type() const
    {
        return _val;
    }
};

void SetPenColor(const Color c)
{
    switch (c)
    {
        case Color::Red:
            // ...
            break;
    }
}

Như ví dụ trên cho thấy, bằng cách sử dụng một lớp, bạn có thể:

1. cấm (thật đáng buồn, không phải thời gian biên dịch) C ++ cho phép ép kiểu từ giá trị không hợp lệ,
2. đặt mặc định (khác 0) cho enums mới tạo,
3. thêm các phương thức khác, như để trả về một biểu diễn chuỗi của một lựa chọn.

Chỉ cần lưu ý rằng bạn cần khai báo operator enum_type()để C ++ biết cách chuyển đổi lớp của bạn thành enum cơ bản. Nếu không, bạn sẽ không thể chuyển loại cho một switchcâu lệnh.

Vì enums được xác định phạm vi bao quanh của chúng, nên có lẽ tốt nhất bạn nên bọc chúng trong một thứ gì đó để tránh làm ô nhiễm không gian tên chung và tránh xung đột tên. Tôi thích một không gian tên hơn cho lớp đơn giản vì namespacecảm giác giống như một cái túi để đựng, trong khi classcảm thấy giống như một đối tượng mạnh mẽ (xem cuộc tranh luận structso với class). Một lợi ích có thể có đối với không gian tên là nó có thể được mở rộng sau này - hữu ích nếu bạn đang xử lý mã của bên thứ ba mà bạn không thể sửa đổi.

Tất nhiên, đây là điều tất nhiên khi chúng ta nhận được các lớp enum với C ++ 0x.

Tôi cũng có xu hướng quấn quýt trong các lớp học.

Như đã được Richard Corden báo hiệu, lợi ích của một lớp là nó là một kiểu theo nghĩa c ++ và vì vậy bạn có thể sử dụng nó với các mẫu.

Tôi có hộp công cụ đặc biệt :: Enum class cho nhu cầu của mình mà tôi chuyên về mọi mẫu cung cấp các chức năng cơ bản (chủ yếu: ánh xạ một giá trị enum thành một chuỗi std :: để I / O dễ đọc hơn).

Mẫu nhỏ của tôi cũng có thêm lợi ích là thực sự kiểm tra các giá trị được phép. Trình biên dịch hơi lỏng lẻo trong việc kiểm tra xem giá trị có thực sự nằm trong enum hay không:

typedef enum { False: 0, True: 2 } boolean;
   // The classic enum you don't want to see around your code ;)

int main(int argc, char* argv[])
{
  boolean x = static_cast<boolean>(1);
  return (x == False || x == True) ? 0 : 1;
} // main

Tôi luôn làm phiền tôi rằng trình biên dịch sẽ không nắm bắt được điều này, vì bạn bị bỏ lại với một giá trị enum vô nghĩa (và bạn sẽ không mong đợi).

Tương tự:

typedef enum { Zero: 0, One: 1, Two: 2 } example;

int main(int argc, char* argv[])
{
  example y = static_cast<example>(3);
  return (y == Zero || y == One || y == Two) ? 0 : 1;
} // main

Một lần nữa main sẽ trả về lỗi.

Vấn đề là trình biên dịch sẽ phù hợp với enum trong biểu diễn nhỏ nhất có sẵn (ở đây chúng ta cần 2 bit) và mọi thứ phù hợp với biểu diễn này được coi là giá trị hợp lệ.

Cũng có một vấn đề là đôi khi bạn muốn có một vòng lặp trên các giá trị có thể có thay vì một công tắc để bạn không phải sửa đổi tất cả các công tắc mà bạn chuyển đổi mỗi khi bạn thêm một giá trị vào enum.

Nói chung, người trợ giúp nhỏ của tôi thực sự dễ dàng mọi thứ cho enum của tôi (tất nhiên, nó thêm một số chi phí) và nó chỉ có thể thực hiện được vì tôi lồng mỗi enum trong cấu trúc của riêng nó :)