ruang nama untuk jenis enum - praktik terbaik

Seringkali, seseorang membutuhkan beberapa jenis yang disebutkan bersama-sama. Terkadang, seseorang memiliki benturan nama. Dua solusi untuk hal ini muncul dalam pikiran: gunakan namespace, atau gunakan nama elemen enum 'lebih besar'. Namun, solusi namespace memiliki dua kemungkinan implementasi: kelas dummy dengan enum bersarang, atau namespace lengkap.

Saya mencari pro dan kontra dari ketiga pendekatan tersebut.

Contoh:

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

Jawaban C ++ 03 asli:

The manfaat dari namespace(atas class) adalah bahwa Anda dapat menggunakan usingdeklarasi ketika Anda ingin.

The masalah dengan menggunakan namespaceadalah bahwa ruang nama dapat diperluas di tempat lain dalam kode. Dalam proyek besar, Anda tidak akan dijamin bahwa dua enum berbeda tidak menganggap keduanya dipanggileFeelings

Untuk kode yang tampak lebih sederhana, saya menggunakan a struct, karena Anda mungkin ingin isinya menjadi publik.

Jika Anda melakukan salah satu dari praktik ini, Anda berada di depan kurva dan mungkin tidak perlu meneliti ini lebih jauh.

Lebih baru, saran C ++ 11:

Jika Anda menggunakan C ++ 11 atau yang lebih baru, enum classsecara implisit akan mencakup nilai enum dalam nama enum.

Dengan enum classAnda akan kehilangan konversi implisit dan perbandingan dengan tipe integer, tetapi dalam praktiknya itu dapat membantu Anda menemukan kode yang ambigu atau buggy.

FYI Di C ++ 0x ada sintaks baru untuk kasus seperti yang Anda sebutkan (lihat halaman wiki C ++ 0x )

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

Saya telah menggabungkan jawaban sebelumnya menjadi seperti ini: (EDIT: Ini hanya berguna untuk pra-C ++ 11. Jika Anda menggunakan C ++ 11, gunakan enum class)

Saya punya satu file header besar yang berisi semua enum proyek saya, karena enum ini dibagi antara kelas pekerja dan tidak masuk akal untuk meletakkan enum di kelas pekerja itu sendiri.

The structmenghindari publik: gula sintaksis, dan typedefmemungkinkan Anda benar-benar mendeklarasikan variabel enum ini dalam kelas pekerja lain.

Saya tidak berpikir menggunakan namespace membantu sama sekali. Mungkin ini karena saya programmer C #, dan di sana Anda harus menggunakan nama tipe enum saat merujuk nilai, jadi saya sudah terbiasa.

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

Saya pasti akan menghindari menggunakan kelas untuk ini; gunakan namespace sebagai gantinya. Pertanyaan intinya adalah apakah akan menggunakan namespace atau menggunakan id unik untuk nilai enum. Secara pribadi, saya akan menggunakan namespace sehingga id saya bisa lebih pendek dan mudah-mudahan lebih jelas. Kemudian kode aplikasi dapat menggunakan arahan 'using namespace' dan membuat semuanya lebih mudah dibaca.

Dari contoh Anda di atas:

using namespace Colors;

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

Perbedaan antara menggunakan kelas atau namespace adalah bahwa kelas tidak dapat dibuka kembali seperti yang bisa dilakukan namespace. Hal ini menghindari kemungkinan bahwa namespace mungkin disalahgunakan di masa mendatang, tetapi ada juga masalah yang tidak dapat Anda tambahkan ke kumpulan enumerasi juga.

Manfaat yang mungkin untuk menggunakan kelas, adalah bahwa mereka dapat digunakan sebagai argumen jenis template, yang tidak berlaku untuk namespace:

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

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

Secara pribadi, saya bukan penggemar penggunaan , dan saya lebih suka nama yang sepenuhnya memenuhi syarat, jadi saya tidak benar-benar melihatnya sebagai nilai tambah untuk namespace. Namun, ini mungkin bukan keputusan terpenting yang akan Anda buat dalam proyek Anda!

Keuntungan menggunakan kelas adalah Anda dapat membangun kelas yang lengkap di atasnya.

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

Seperti yang ditunjukkan contoh di atas, dengan menggunakan kelas Anda dapat:

1. melarang (sayangnya, bukan waktu kompilasi) C ++ mengizinkan cast dari nilai yang tidak valid,
2. setel default (bukan nol) untuk enum yang baru dibuat,
3. tambahkan metode lebih lanjut, seperti mengembalikan representasi string pilihan.

Perhatikan saja bahwa Anda perlu mendeklarasikan operator enum_type()agar C ++ tahu cara mengubah kelas Anda menjadi enum yang mendasarinya. Jika tidak, Anda tidak akan bisa meneruskan tipe ke switchpernyataan.

Karena enum tercakup dalam cakupannya, mungkin yang terbaik adalah membungkusnya dengan sesuatu untuk menghindari mencemari namespace global dan membantu menghindari benturan nama. Saya lebih suka namespace daripada kelas hanya karena namespaceterasa seperti sekantong penyimpanan, sedangkan classterasa seperti objek yang kuat (lih. Debat structvs. class). Manfaat yang mungkin untuk namespace adalah bahwa ia dapat diperpanjang nanti - berguna jika Anda berurusan dengan kode pihak ketiga yang tidak dapat Anda modifikasi.

Ini semua tentu saja bisa diperdebatkan ketika kita mendapatkan kelas enum dengan C ++ 0x.

Saya juga cenderung menyelesaikan enum saya di kelas.

Seperti yang diisyaratkan oleh Richard Corden, keuntungan dari sebuah kelas adalah ia merupakan tipe dalam pengertian c ++ sehingga Anda dapat menggunakannya dengan template.

Saya memiliki toolbox :: kelas Enum khusus untuk kebutuhan saya yang saya spesialisasikan untuk setiap template yang menyediakan fungsi dasar (terutama: memetakan nilai enum ke std :: string sehingga I / O lebih mudah dibaca).

Template kecil saya juga memiliki manfaat tambahan untuk benar-benar memeriksa nilai yang diizinkan. Kompiler agak lalai dalam memeriksa apakah nilainya benar-benar ada di 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

Itu selalu mengganggu saya bahwa kompiler tidak akan menangkap ini, karena Anda ditinggalkan dengan nilai enum yang tidak masuk akal (dan Anda tidak akan mengharapkannya).

Demikian pula:

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

Sekali lagi main akan mengembalikan kesalahan.

Masalahnya adalah bahwa kompilator akan menyesuaikan enum dalam representasi terkecil yang tersedia (di sini kita membutuhkan 2 bit) dan semua yang cocok dalam representasi ini dianggap sebagai nilai yang valid.

Ada juga masalah bahwa terkadang Anda lebih suka memiliki loop pada nilai yang mungkin daripada sebuah sakelar sehingga Anda tidak perlu mengubah semua sakelar Anda setiap kali Anda menambahkan nilai ke enum.

Semua dalam semua penolong kecil saya benar-benar memudahkan hal-hal untuk enum saya (tentu saja, ini menambahkan beberapa overhead) dan itu hanya mungkin karena saya menyusun setiap enum di struct sendiri :)