(Bagaimana) saya bisa menghitung item dalam enum?

Pertanyaan ini muncul di benak saya, ketika saya memiliki sesuatu seperti

enum Folders {FA, FB, FC};

dan ingin membuat berbagai wadah untuk setiap folder:

ContainerClass*m_containers[3];
....
m_containers[FA] = ...; // etc.

(Menggunakan peta, ini jauh lebih elegan untuk digunakan std::map<Folders, ContainerClass*> m_containers;:)

Tetapi untuk kembali ke pertanyaan awal saya: Bagaimana jika saya tidak ingin membuat kode keras ukuran array, adakah cara untuk mengetahui berapa banyak item yang ada di Folder? (Tanpa bergantung pada misalnya FCmenjadi item terakhir dalam daftar yang akan memungkinkan sesuatu seperti ContainerClass*m_containers[FC+1]jika saya tidak salah.)

Sebenarnya tidak ada cara yang baik untuk melakukan ini, biasanya Anda melihat item tambahan di enum, yaitu

enum foobar {foo, bar, baz, quz, FOOBAR_NR_ITEMS};

Jadi, Anda dapat melakukan:

int fuz[FOOBAR_NR_ITEMS];

Masih tidak terlalu bagus.

Tapi tentu saja Anda menyadari bahwa jumlah item dalam enum tidaklah aman, misalnya

enum foobar {foo, bar = 5, baz, quz = 20};

jumlah item akan menjadi 4, tetapi nilai integer dari nilai enum akan keluar dari rentang indeks array. Menggunakan nilai enum untuk pengindeksan array tidak aman, Anda harus mempertimbangkan opsi lain.

edit: seperti yang diminta, membuat entri khusus lebih menonjol.

Untuk C ++, ada berbagai teknik enum tipe aman yang tersedia, dan beberapa di antaranya (seperti Boost.Enum yang diusulkan tetapi tidak pernah dikirimkan ) menyertakan dukungan untuk mendapatkan ukuran enum.

Pendekatan paling sederhana, yang berfungsi di C dan juga C ++, adalah mengadopsi konvensi mendeklarasikan nilai ... MAX untuk setiap jenis enum Anda:

enum Folders { FA, FB, FC, Folders_MAX = FC };
ContainerClass *m_containers[Folders_MAX + 1];
....
m_containers[FA] = ...; // etc.

Sunting : Mengenai { FA, FB, FC, Folders_MAX = FC}versus {FA, FB, FC, Folders_MAX]: Saya lebih suka menyetel nilai ... MAX ke nilai legal terakhir dari enum karena beberapa alasan:

1. Nama konstanta secara teknis lebih akurat (karena Folders_MAXmemberikan nilai enum semaksimal mungkin).
2. Secara pribadi, saya merasa Folders_MAX = FCmenonjol dari entri lain sedikit lebih (membuatnya sedikit lebih sulit untuk secara tidak sengaja menambahkan nilai enum tanpa memperbarui nilai maksimal, masalah yang direferensikan Martin York).
3. GCC menyertakan peringatan bermanfaat seperti "nilai enumerasi tidak disertakan dalam sakelar" untuk kode seperti berikut ini. Membiarkan Folders_MAX == FC + 1 merusak peringatan itu, karena Anda berakhir dengan sekumpulan ... MAX nilai pencacahan yang seharusnya tidak pernah disertakan dalam sakelar.

saklar (folder) 
{
  kasus FA: ...;
  kasus FB: ...;
  // Ups, lupakan FC!
}

Bagaimana dengan ciri-ciri, dalam gaya STL? Misalnya:

enum Foo
{
    Bar,
    Baz
};

menulis sebuah

std::numeric_limits<enum Foo>::max()

spesialisasi (mungkin constexpr jika Anda menggunakan c ++ 11). Kemudian, dalam kode pengujian Anda, berikan pernyataan statis apa pun untuk mempertahankan batasan yang std :: numeric_limits :: max () = last_item.

Tambahkan entri, di akhir enum Anda, yang disebut Folders_MAX atau sesuatu yang serupa dan gunakan nilai ini saat menginisialisasi array Anda.

ContainerClass* m_containers[Folders_MAX];

Saya suka menggunakan enum sebagai argumen untuk fungsi saya. Ini adalah cara yang mudah untuk memberikan daftar tetap "opsi". Masalah dengan jawaban pilihan teratas di sini adalah bahwa dengan menggunakan itu, klien dapat menentukan "opsi tidak valid". Sebagai spin off, saya sarankan melakukan hal yang pada dasarnya sama, tetapi gunakan int konstan di luar enum untuk menentukan jumlah mereka.

enum foobar { foo, bar, baz, quz };
const int FOOBAR_NR_ITEMS=4;

Ini tidak menyenangkan, tetapi ini adalah solusi yang bersih jika Anda tidak mengubah enum tanpa memperbarui konstanta.

Saya benar-benar tidak melihat cara apa pun untuk benar-benar mendapatkan jumlah nilai dalam pencacahan di C ++. Salah satu solusi yang disebutkan sebelumnya berfungsi selama Anda tidak menentukan nilai enumerasi Anda jika Anda menentukan nilai yang mungkin Anda hadapi dalam situasi di mana Anda membuat array terlalu besar atau terlalu kecil

enum example{ test1 = -2, test2 = -1, test3 = 0, test4 = 1, test5 = 2 }

dalam contoh tentang ini, hasilnya akan membuat larik 3 item saat Anda membutuhkan larik 5 item

enum example2{ test1 , test2 , test3 , test4 , test5 = 301 }

dalam contoh tentang ini, hasilnya akan membuat array 301 item ketika Anda membutuhkan array yang terdiri dari 5 item

Cara terbaik untuk menyelesaikan masalah ini dalam kasus umum adalah dengan mengulang melalui pencacahan Anda tetapi itu belum sesuai standar sejauh yang saya tahu