เนมสเปซสำหรับประเภท enum - แนวทางปฏิบัติที่ดีที่สุด

บ่อยครั้งหนึ่งต้องมีการแจกแจงหลายประเภทด้วยกัน บางครั้งคนหนึ่งมีชื่อปะทะกัน วิธีแก้ปัญหาสองวิธีสำหรับสิ่งนี้: ใช้เนมสเปซหรือใช้ชื่อองค์ประกอบ enum ที่ 'ใหญ่กว่า' อย่างไรก็ตามโซลูชันเนมสเปซยังมีการใช้งานที่เป็นไปได้สองแบบ: คลาสดัมมี่ที่มี enum ซ้อนกันหรือเนมสเปซแบบเต็ม

ฉันกำลังมองหาข้อดีข้อเสียของทั้งสามวิธี

ตัวอย่าง:

// 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 ++ 03 ดั้งเดิม:

ประโยชน์จากnamespace(กว่าclass) คือการที่คุณสามารถใช้usingการประกาศเมื่อคุณต้องการ

ปัญหากับการใช้namespaceเป็นที่ namespaces สามารถขยายตัวอื่น ๆ ในรหัส ในโปรเจ็กต์ขนาดใหญ่คุณจะไม่ได้รับการรับรองว่าสอง enums ที่แตกต่างกันจะไม่คิดว่าทั้งคู่ถูกเรียกeFeelings

สำหรับโค้ดที่ดูง่ายขึ้นฉันใช้ a structเนื่องจากคุณน่าจะต้องการให้เนื้อหาเป็นแบบสาธารณะ

หากคุณกำลังทำตามแนวทางปฏิบัติเหล่านี้แสดงว่าคุณอยู่เหนือเส้นโค้งและอาจไม่จำเป็นต้องพิจารณาเรื่องนี้เพิ่มเติม

ใหม่กว่าคำแนะนำ C ++ 11:

หากคุณใช้ C ++ 11 หรือใหม่กว่าenum classจะกำหนดขอบเขตค่า enum ภายในชื่อ enum โดยปริยาย

ด้วยenum classคุณจะสูญเสียการแปลงโดยปริยายและการเปรียบเทียบกับประเภทจำนวนเต็ม แต่ในทางปฏิบัติที่อาจช่วยให้คุณค้นพบรหัสที่ไม่ชัดเจนหรือรถ

FYI ใน C ++ 0x มีไวยากรณ์ใหม่สำหรับกรณีเช่นที่คุณกล่าวถึง (ดูหน้าวิกิ C ++ 0x )

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

ฉันได้ผสมคำตอบก่อนหน้านี้ไว้กับสิ่งนี้: (แก้ไข: สิ่งนี้มีประโยชน์สำหรับ C ++ 11 ก่อนหน้านี้เท่านั้นหากคุณใช้ C ++ 11 ให้ใช้enum class)

ฉันมีไฟล์ส่วนหัวขนาดใหญ่หนึ่งไฟล์ที่มี enums โปรเจ็กต์ทั้งหมดของฉันเนื่องจาก enums เหล่านี้ใช้ร่วมกันระหว่างคลาสของผู้ปฏิบัติงานและมันไม่สมเหตุสมผลที่จะใส่ enums ในคลาสของผู้ปฏิบัติงานเอง

structหลีกเลี่ยงส่วนกลาง: น้ำตาลประโยคและtypedefช่วยให้คุณจริงประกาศตัวแปรของ enums เหล่านี้ภายในชั้นเรียนของผู้ปฏิบัติงานอื่น ๆ

ฉันไม่คิดว่าการใช้เนมสเปซช่วยเลย อาจเป็นเพราะฉันเป็นโปรแกรมเมอร์ C # และคุณต้องใช้ชื่อประเภท enum เมื่ออ้างถึงค่าดังนั้นฉันจึงคุ้นเคยกับมัน

    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: ... ;
    }
}

แน่นอนฉันจะหลีกเลี่ยงการใช้ชั้นเรียนนี้ ใช้เนมสเปซแทน คำถามจะสรุปว่าจะใช้เนมสเปซหรือใช้รหัสเฉพาะสำหรับค่า enum โดยส่วนตัวแล้วฉันจะใช้เนมสเปซเพื่อให้รหัสของฉันสั้นลงและหวังว่าจะอธิบายตัวเองได้มากขึ้น จากนั้นรหัสแอปพลิเคชันสามารถใช้คำสั่ง 'การใช้เนมสเปซ' และทำให้ทุกอย่างอ่านง่ายขึ้น

จากตัวอย่างของคุณด้านบน:

using namespace Colors;

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

ความแตกต่างระหว่างการใช้คลาสหรือเนมสเปซคือไม่สามารถเปิดคลาสใหม่ได้เหมือนที่เนมสเปซทำได้ วิธีนี้หลีกเลี่ยงความเป็นไปได้ที่เนมสเปซอาจถูกใช้ในทางที่ผิดในอนาคต แต่ยังมีปัญหาที่คุณไม่สามารถเพิ่มลงในชุดการแจงนับได้

ประโยชน์ที่เป็นไปได้สำหรับการใช้คลาสคือสามารถใช้เป็นอาร์กิวเมนต์ประเภทเทมเพลตได้ซึ่งไม่ใช่กรณีสำหรับเนมสเปซ:

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

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

โดยส่วนตัวแล้วฉันไม่ใช่แฟนของการใช้และฉันชอบชื่อที่มีคุณสมบัติครบถ้วนดังนั้นฉันจึงไม่เห็นว่าเป็นประโยชน์สำหรับเนมสเปซ อย่างไรก็ตามนี่อาจไม่ใช่การตัดสินใจที่สำคัญที่สุดที่คุณจะต้องทำในโครงการของคุณ!

ข้อดีของการใช้คลาสคือคุณสามารถสร้างคลาสที่มีคุณสมบัติครบถ้วนด้านบนได้

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

ดังตัวอย่างข้างต้นแสดงโดยใช้คลาสคุณสามารถ:

1. ห้าม (น่าเศร้าไม่ใช่เวลาคอมไพล์) C ++ ไม่อนุญาตให้แคสต์จากค่าที่ไม่ถูกต้อง
2. ตั้งค่าเริ่มต้น (ไม่ใช่ศูนย์) สำหรับ enums ที่สร้างขึ้นใหม่
3. เพิ่มวิธีการเพิ่มเติมเช่นการส่งคืนการแสดงสตริงของตัวเลือก

โปรดทราบว่าคุณต้องประกาศoperator enum_type()เพื่อที่ C ++ จะได้รู้วิธีแปลงคลาสของคุณเป็น enum พื้นฐาน มิฉะนั้นคุณจะไม่สามารถส่งผ่านประเภทไปยังswitchคำสั่งได้

เนื่องจาก enums ถูกกำหนดขอบเขตไว้ในขอบเขตการปิดล้อมจึงควรห่อหุ้มไว้ในบางสิ่งเพื่อหลีกเลี่ยงการสร้างมลพิษให้กับเนมสเปซทั่วโลกและเพื่อช่วยหลีกเลี่ยงการชนกันของชื่อ ฉันชอบเนมสเปซในการเรียนเพียงเพราะให้namespaceความรู้สึกเหมือนกระเป๋าถือในขณะที่ให้classความรู้สึกเหมือนเป็นวัตถุที่แข็งแกร่ง ( structเปรียบเทียบกับclassการอภิปราย) ประโยชน์ที่เป็นไปได้ของเนมสเปซคือสามารถขยายได้ในภายหลัง - มีประโยชน์หากคุณกำลังจัดการกับโค้ดของบุคคลที่สามที่คุณไม่สามารถแก้ไขได้

นี่คือสิ่งที่น่าสงสัยทั้งหมดเมื่อเราได้เรียน enum ด้วย C ++ 0x

ฉันมักจะห่อ enums ของฉันในชั้นเรียน

ตามสัญญาณของ Richard Corden ประโยชน์ของคลาสคือเป็นประเภทหนึ่งในความหมาย c ++ คุณจึงสามารถใช้กับเทมเพลตได้

ฉันมีกล่องเครื่องมือพิเศษ :: คลาส Enum สำหรับความต้องการของฉันซึ่งฉันเชี่ยวชาญสำหรับทุกเทมเพลตที่มีฟังก์ชันพื้นฐาน (ส่วนใหญ่: การแมปค่า enum กับสตริง std :: เพื่อให้ I / O อ่านง่ายขึ้น)

แม่แบบเล็ก ๆ ของฉันยังมีประโยชน์เพิ่มเติมในการตรวจสอบค่าที่อนุญาตจริงๆ คอมไพเลอร์ค่อนข้างหละหลวมในการตรวจสอบว่าค่าอยู่ใน enum จริงหรือไม่:

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

มันรบกวนฉันเสมอที่คอมไพเลอร์จะไม่จับสิ่งนี้เนื่องจากคุณเหลือค่า enum ที่ไม่มีความรู้สึก (และคุณจะไม่คาดคิด)

ในทำนองเดียวกัน:

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

หลักอีกครั้งจะส่งคืนข้อผิดพลาด

ปัญหาคือคอมไพเลอร์จะพอดีกับ enum ในการแทนค่าที่เล็กที่สุดที่มีอยู่ (ในที่นี้เราต้องการ 2 บิต) และทุกอย่างที่พอดีกับการแทนค่านี้ถือว่าเป็นค่าที่ถูกต้อง

นอกจากนี้ยังมีปัญหาที่บางครั้งคุณต้องการวนซ้ำกับค่าที่เป็นไปได้แทนที่จะเป็นสวิตช์เพื่อที่คุณจะได้ไม่ต้องแก้ไขสวิตช์ทั้งหมดที่คุณเปลี่ยนทุกครั้งที่คุณเพิ่มค่าให้กับ enum

โดยรวมแล้วผู้ช่วยตัวน้อยของฉันช่วยบรรเทาสิ่งต่าง ๆ ให้กับ enums ของฉันได้อย่างแท้จริง (แน่นอนว่ามันเพิ่มค่าใช้จ่ายบางส่วน) และเป็นไปได้เพียงเพราะฉันซ้อนแต่ละ enum ในโครงสร้างของมันเอง :)