Teruskan mendeklarasikan enum dalam C ++

Saya mencoba melakukan sesuatu seperti berikut:

enum E;

void Foo(E e);

enum E {A, B, C};

yang ditolak kompilator. Saya sudah melihat sekilas di Google dan konsensusnya adalah "Anda tidak bisa melakukannya", tetapi saya tidak mengerti mengapa. Adakah yang bisa menjelaskan?

Klarifikasi 2: Saya melakukan ini karena saya memiliki metode pribadi di kelas yang mengambil kata enum, dan saya tidak ingin nilai-nilai enum terbuka - jadi, misalnya, saya tidak ingin ada yang tahu bahwa E didefinisikan sebagai

enum E {
    FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X
}

sebagai proyek X bukanlah sesuatu yang saya ingin pengguna saya ketahui.

Jadi, saya ingin meneruskan mendeklarasikan enum sehingga saya bisa meletakkan metode pribadi di file header, mendeklarasikan enum secara internal di cpp, dan mendistribusikan file library yang dibangun dan header ke orang.

Adapun kompiler - itu GCC.

Alasan enum tidak dapat diteruskan dinyatakan adalah bahwa tanpa mengetahui nilai-nilai, kompiler tidak dapat mengetahui penyimpanan yang diperlukan untuk variabel enum. C ++ Compiler diperbolehkan untuk menentukan ruang penyimpanan aktual berdasarkan ukuran yang diperlukan untuk memuat semua nilai yang ditentukan. Jika semua yang terlihat adalah deklarasi maju, unit terjemahan tidak dapat mengetahui ukuran penyimpanan apa yang akan dipilih - bisa berupa char atau int, atau yang lainnya.

Dari Bagian 7.2.5 Standar ISO C ++:

The jenis yang mendasari sebuah enumerasi adalah tipe integral yang dapat mewakili semua nilai pencacah didefinisikan dalam pencacahan. Ini adalah implementasi-didefinisikan jenis integral yang digunakan sebagai tipe yang mendasari untuk enumerasi kecuali bahwa tipe yang mendasari tidak boleh lebih besar dari intkecuali jika nilai enumerator tidak dapat ditampung dalam suatu intatau unsigned int. Jika daftar enumerator kosong, tipe yang mendasari adalah seolah-olah enumerasi memiliki enumerator tunggal dengan nilai 0. Nilai yang sizeof()diterapkan pada tipe enumerasi, objek tipe enumerasi, atau enumerator, adalah nilai yang sizeof()diterapkan pada tipe yang mendasarinya.

Karena penelepon ke fungsi harus mengetahui ukuran parameter untuk mengatur tumpukan panggilan dengan benar, jumlah enumerasi dalam daftar enumerasi harus diketahui sebelum prototipe fungsi.

Pembaruan: Dalam C ++ 0X sintaks untuk kata kunci yang menyatakan jenis enum telah diusulkan dan diterima. Anda dapat melihat proposal di http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf

Deklarasi maju enum dimungkinkan karena C ++ 11. Sebelumnya, alasan tipe enum tidak dapat diteruskan adalah karena ukuran enumerasi tergantung pada isinya. Selama ukuran enumerasi ditentukan oleh aplikasi, itu dapat dinyatakan maju:

enum Enum1;                   //Illegal in C++ and C++0x; no size is explicitly specified.
enum Enum2 : unsigned int;    //Legal in C++0x.
enum class Enum3;             //Legal in C++0x, because enum class declarations have a default type of "int".
enum class Enum4: unsigned int; //Legal C++0x.
enum Enum2 : unsigned short;  //Illegal in C++0x, because Enum2 was previously declared with a different type.

Saya menambahkan jawaban terkini di sini, mengingat perkembangan terakhir.

Anda dapat meneruskan-mendeklarasikan enum di C ++ 11, selama Anda mendeklarasikan tipe penyimpanannya pada saat yang sama. Sintaksnya terlihat seperti ini:

enum E : short;
void foo(E e);

....

enum E : short
{
    VALUE_1,
    VALUE_2,
    ....
}

Bahkan, jika fungsi tidak pernah merujuk pada nilai-nilai enumerasi, Anda tidak perlu deklarasi lengkap sama sekali pada saat itu.

Ini didukung oleh G ++ 4.6 dan seterusnya ( -std=c++0xatau -std=c++11dalam versi yang lebih baru). Visual C ++ 2013 mendukung ini; dalam versi sebelumnya ia memiliki semacam dukungan non-standar yang belum saya temukan - saya menemukan beberapa saran bahwa deklarasi maju sederhana itu legal, tetapi YMMV.

Maju menyatakan hal-hal dalam C ++ sangat berguna karena secara dramatis mempercepat waktu kompilasi . Anda maju dapat mendeklarasikan beberapa hal di C ++ termasuk: struct, class, function, dll ...

Tapi bisakah Anda meneruskan menyatakan enumdalam C ++?

Tidak, kamu tidak bisa.

Tapi mengapa tidak membiarkannya? Jika diizinkan, Anda dapat menentukan enumjenis Anda di file header Anda, dan enumnilai - nilai Anda di file sumber Anda. Kedengarannya seperti itu harus diizinkan kan?

Salah.

Di C ++ tidak ada tipe default untuk enumseperti ada di C # (int). Dalam C ++ enumtipe Anda akan ditentukan oleh kompiler untuk menjadi tipe apa pun yang akan cocok dengan rentang nilai yang Anda miliki untuk Anda enum.

Apa artinya?

Ini berarti bahwa enumtipe dasar Anda tidak dapat sepenuhnya ditentukan sampai Anda memiliki semua nilai yang enumditentukan. Orang mana yang tidak dapat Anda pisahkan dari deklarasi dan definisi Anda enum. Dan karena itu Anda tidak dapat meneruskan mendeklarasikan enumdalam C ++.

Standar ISO C ++ S7.2.5:

Tipe yang mendasari enumerasi adalah tipe integral yang dapat mewakili semua nilai enumerator yang didefinisikan dalam enumerasi. Ini adalah implementasi-didefinisikan jenis integral yang digunakan sebagai tipe yang mendasari untuk enumerasi kecuali bahwa tipe yang mendasari tidak boleh lebih besar dari intkecuali jika nilai enumerator tidak dapat ditampung dalam suatu intatau unsigned int. Jika daftar enumerator kosong, tipe yang mendasari adalah seolah-olah enumerasi memiliki enumerator tunggal dengan nilai 0. Nilai yang sizeof()diterapkan pada tipe enumerasi, objek tipe enumerasi, atau enumerator, adalah nilai yang sizeof()diterapkan pada tipe yang mendasarinya.

Anda dapat menentukan ukuran tipe yang disebutkan dalam C ++ dengan menggunakan sizeofoperator. Ukuran dari tipe yang disebutkan adalah ukuran dari tipe yang mendasarinya. Dengan cara ini Anda bisa menebak jenis yang digunakan kompiler untuk Anda enum.

Bagaimana jika Anda menentukan jenis Anda enumsecara eksplisit seperti ini:

enum Color : char { Red=0, Green=1, Blue=2};
assert(sizeof Color == 1);

Bisakah Anda meneruskan menyatakan Anda enum?

Tapi mengapa tidak?

Menentukan jenis suatu enumsebenarnya bukan bagian dari standar C ++ saat ini. Ini adalah ekstensi VC ++. Ini akan menjadi bagian dari C ++ 0x.

Sumber

[Jawaban saya salah, tetapi saya meninggalkannya di sini karena komentarnya bermanfaat].

Penerusan mendeklarasikan enum adalah non-standar, karena pointer ke tipe enum yang berbeda tidak dijamin ukurannya sama. Compiler mungkin perlu melihat definisi untuk mengetahui ukuran pointer apa yang dapat digunakan dengan tipe ini.

Dalam praktiknya, setidaknya pada semua kompiler populer, pointer ke enum adalah ukuran yang konsisten. Deklarasi maju enum disediakan sebagai ekstensi bahasa oleh Visual C ++, misalnya.

Memang tidak ada yang namanya deklarasi maju enum. Karena definisi enum tidak mengandung kode apa pun yang bisa bergantung pada kode lain menggunakan enum, biasanya bukan masalah untuk mendefinisikan enum sepenuhnya ketika Anda pertama kali mendeklarasikannya.

Jika satu-satunya penggunaan enum Anda adalah dengan fungsi anggota pribadi, Anda dapat mengimplementasikan enkapsulasi dengan menjadikan enum itu sendiri sebagai anggota pribadi kelas itu. Enum masih harus sepenuhnya didefinisikan pada titik deklarasi, yaitu, dalam definisi kelas. Namun, ini bukan masalah yang lebih besar dengan mendeklarasikan fungsi anggota privat di sana, dan bukan eksposur internal implementasi yang lebih buruk dari itu.

Jika Anda membutuhkan tingkat penyembunyian yang lebih dalam untuk detail implementasi Anda, Anda dapat memecahnya menjadi antarmuka abstrak, hanya terdiri dari fungsi virtual murni, dan implementasi antarmuka (pewarisan) antarmuka yang nyata, sangat tersembunyi. Pembuatan instance kelas dapat ditangani oleh pabrik atau fungsi anggota statis dari antarmuka. Dengan begitu, bahkan nama kelas sebenarnya, apalagi fungsi privatnya, tidak akan diekspos.

Hanya mencatat bahwa alasan sebenarnya adalah bahwa ukuran enum belum diketahui setelah deklarasi maju. Nah, Anda menggunakan deklarasi maju dari sebuah struct untuk dapat melewati sebuah pointer di sekitar atau merujuk ke suatu objek dari tempat yang dirujuk dalam definisi struct yang dinyatakan maju itu sendiri juga.

Meneruskan mendeklarasikan enum tidak akan terlalu berguna, karena seseorang ingin dapat membagikan enum berdasarkan nilai. Anda bahkan tidak dapat memiliki pointer ke sana, karena saya baru-baru ini diberitahu beberapa platform menggunakan pointer ukuran yang berbeda untuk char daripada untuk int atau panjang. Jadi itu semua tergantung pada isi enum.

Standar C ++ saat ini secara eksplisit melarang melakukan sesuatu seperti

enum X;

(dalam 7.1.5.3/1). Tapi berikutnya C ++ Standar karena tahun depan memungkinkan berikut, yang meyakinkan saya masalah sebenarnya memiliki hubungannya dengan jenis yang mendasari:

enum X : int;

Ini dikenal sebagai deklarasi enum "buram". Anda bahkan dapat menggunakan X dengan nilai dalam kode berikut. Dan pencacahnya nanti dapat didefinisikan dalam deklarasi ulang pencacahan nanti. Lihat 7.2di draft kerja saat ini.

Saya akan melakukannya dengan cara ini:

[di tajuk publik]

typedef unsigned long E;

void Foo(E e);

[di tajuk internal]

enum Econtent { FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X,
  FORCE_32BIT = 0xFFFFFFFF };

Dengan menambahkan FORCE_32BIT, kami memastikan Econtent mengkompilasi ke panjang, sehingga dapat dipertukarkan dengan E.

Jika Anda benar-benar tidak ingin enum Anda muncul di file header Anda DAN memastikan bahwa itu hanya digunakan dengan metode pribadi, maka salah satu solusinya adalah dengan prinsip pimpl.

Ini adalah teknik yang memastikan untuk menyembunyikan internal kelas di header dengan hanya menyatakan:

class A 
{
public:
    ...
private:
    void* pImpl;
};

Kemudian dalam file implementasi Anda (cpp), Anda mendeklarasikan kelas yang akan menjadi representasi internal.

class AImpl
{
public:
    AImpl(A* pThis): m_pThis(pThis) {}

    ... all private methods here ...
private:
    A* m_pThis;
};

Anda harus secara dinamis membuat implementasi di konstruktor kelas dan menghapusnya di destruktor dan ketika menerapkan metode publik, Anda harus menggunakan:

((AImpl*)pImpl)->PrivateMethod();

Ada pro untuk menggunakan pimpl, salah satunya adalah decouple header kelas Anda dari implementasinya, tidak perlu mengkompilasi ulang kelas lain saat mengubah implementasi satu kelas. Lain adalah mempercepat waktu kompilasi Anda karena header Anda sangat sederhana.

Tapi itu sulit digunakan, jadi Anda harus bertanya pada diri sendiri apakah hanya menyatakan enum sebagai pribadi di header adalah masalah besar.

Anda dapat membungkus enum dalam sebuah struct, menambahkan beberapa konstruktor dan mengetik konversi, dan meneruskan mendeklarasikan struct sebagai gantinya.

#define ENUM_CLASS(NAME, TYPE, VALUES...) \
struct NAME { \
    enum e { VALUES }; \
    explicit NAME(TYPE v) : val(v) {} \
    NAME(e v) : val(v) {} \
    operator e() const { return e(val); } \
    private:\
        TYPE val; \
}

Tampaknya ini berfungsi: http://ideone.com/TYtP2

Tampaknya tidak dapat dideklarasikan ke depan dalam GCC!

Diskusi yang menarik di sini

Ada beberapa perbedaan pendapat karena ini terbentur (semacam), jadi inilah beberapa bit yang relevan dari standar. Penelitian menunjukkan bahwa standar tersebut tidak benar-benar mendefinisikan deklarasi maju, juga tidak secara eksplisit menyatakan bahwa enum dapat atau tidak dapat dinyatakan maju.

Pertama, dari dcl.enum, bagian 7.2:

Tipe yang mendasari enumerasi adalah tipe integral yang dapat mewakili semua nilai enumerator yang didefinisikan dalam enumerasi. Ini adalah implementasi-didefinisikan tipe integral mana yang digunakan sebagai tipe yang mendasari untuk enumerasi kecuali bahwa tipe yang mendasari tidak boleh lebih besar dari int kecuali nilai enumerator tidak dapat ditampung dalam int atau int unsigned. Jika daftar enumerator kosong, tipe yang mendasarinya adalah seolah-olah enumerasi memiliki enumerator tunggal dengan nilai 0. Nilai sizeof () diterapkan pada tipe enumerasi, objek tipe enumerasi, atau enumerator, adalah nilai dari sizeof () diterapkan pada tipe yang mendasarinya.

Jadi, jenis enum yang mendasarinya adalah implementasi yang ditentukan, dengan satu batasan kecil.

Selanjutnya kita beralih ke bagian "tipe tidak lengkap" (3,9), yaitu hampir sedekat yang kita lihat dengan standar apa pun pada deklarasi maju:

Kelas yang telah dideklarasikan tetapi tidak didefinisikan, atau array dengan ukuran yang tidak diketahui atau tipe elemen yang tidak lengkap, adalah tipe objek yang tidak didefinisikan dengan sempurna.

Tipe kelas (seperti "kelas X") mungkin tidak lengkap pada satu titik di unit terjemahan dan selesai nanti; tipe "kelas X" adalah tipe yang sama di kedua titik. Tipe objek array yang dideklarasikan mungkin berupa array tipe kelas tidak lengkap dan karenanya tidak lengkap; jika tipe kelas selesai nanti di dalam unit terjemahan, tipe array menjadi lengkap; tipe array pada kedua titik tersebut adalah tipe yang sama. Tipe objek array yang dideklarasikan mungkin berupa array dengan ukuran yang tidak diketahui dan karenanya tidak lengkap pada satu titik dalam unit terjemahan dan selesai nanti; tipe-tipe array pada kedua titik tersebut ("array dengan batas tidak diketahui T" dan "array dari N T") adalah tipe yang berbeda. Jenis pointer ke array dengan ukuran yang tidak diketahui, atau tipe yang didefinisikan oleh deklarasi typedef menjadi array dengan ukuran yang tidak diketahui,

Jadi disana, standarnya cukup banyak ditata jenis-jenis yang bisa dideklarasikan. Enum tidak ada di sana, jadi penulis kompiler umumnya menganggap forward menyatakan tidak diizinkan oleh standar karena ukuran variabel dari tipe yang mendasarinya.

Masuk akal juga. Enum biasanya dirujuk dalam situasi menurut nilai, dan kompiler memang perlu mengetahui ukuran penyimpanan dalam situasi tersebut. Karena ukuran penyimpanan adalah implementasi yang ditentukan, banyak kompiler hanya dapat memilih untuk menggunakan nilai 32 bit untuk tipe yang mendasari setiap enum, di mana pada saat itu dimungkinkan untuk meneruskannya. Eksperimen yang menarik mungkin adalah dengan mencoba mendeklarasikan enum di studio visual, kemudian memaksanya untuk menggunakan tipe dasar yang lebih besar dari sizeof (int) seperti yang dijelaskan di atas untuk melihat apa yang terjadi.

Untuk VC, inilah ujian tentang penerusan deklarasi dan menentukan tipe yang mendasarinya:

1. kode berikut dikompilasi ok.

    ketikkan int myint;
    enum T;
    batal foo (T * tp)
    {
        * tp = (T) 0x12345678;
    }
    enum T: char
    {
        SEBUAH
    };

Tetapi mendapat peringatan untuk / W4 (/ W3 tidak dikenakan peringatan ini)

peringatan C4480: ekstensi tidak standar yang digunakan: menentukan tipe yang mendasari untuk enum 'T'

2. VC (Microsoft (R) 32-bit C / C ++ Mengoptimalkan Versi Kompiler 15.00.30729.01 untuk 80x86) terlihat bermasalah dalam kasus di atas:

   • saat melihat enum T; VC mengasumsikan enum tipe T menggunakan int standar 4 byte sebagai tipe yang mendasarinya, sehingga kode perakitan yang dihasilkan adalah:

    ? foo @@ YAXPAW4T @@@ Z PROC; foo
    ; File e: \ work \ c_cpp \ cpp_snippet.cpp
    ; Baris 13
        tekan ebp
        mov ebp, esp
    ; Baris 14
        mov eax, DWORD PTR _tp $ [ebp]
        mov DWORD PTR [eax], 305419896; 12345678H
    ; Baris 15
        pop ebp
        ret 0
    ? foo @@ YAXPAW4T @@@ Z ENDP; foo

Kode rakitan di atas diekstraksi dari /Fatest.asm secara langsung, bukan tebakan pribadi saya. Apakah Anda melihat mov DWORD PTR [eax], 305419896; Baris 12345678H?

cuplikan kode berikut membuktikannya:

    int main (int argc, char * argv)
    {
        Persatuan {
            char ca [4];
            Tt;
        }Sebuah;
        a.ca [0] = a.ca [1] = a. [ca [2] = a.ca [3] = 1;
        foo (& a.t);
        printf ("% # x,% # x,% # x,% # x \ n", a.ca [0], a.ca [1], a.ca [2], a.ca [3]) ;
        return 0;
    }

hasilnya adalah: 0x78, 0x56, 0x34, 0x12

• setelah menghapus deklarasi maju enum T dan pindahkan definisi fungsi foo setelah definisi enum T: hasilnya OK:

instruksi kunci di atas menjadi:

mov BYTE PTR [eax], 120; 00000078H

hasil akhirnya adalah: 0x78, 0x1, 0x1, 0x1

Perhatikan nilainya tidak ditimpa

Jadi penggunaan maju-deklarasi enum di VC dianggap berbahaya.

BTW, tidak mengherankan, sintaks untuk deklarasi tipe yang mendasarinya sama dengan di C #. Dalam praktiknya saya menemukan itu layak untuk menyimpan 3 byte dengan menentukan tipe yang mendasarinya sebagai char ketika berbicara dengan sistem tertanam, yang merupakan memori terbatas.

Dalam proyek saya, saya mengadopsi teknik Namespace-Bound Enumeration untuk menangani enumkomponen warisan dan pihak ketiga. Berikut ini sebuah contoh:

forward.h:

namespace type
{
    class legacy_type;
    typedef const legacy_type& type;
}

enum.h:

// May be defined here or pulled in via #include.
namespace legacy
{
    enum evil { x , y, z };
}


namespace type
{
    using legacy::evil;

    class legacy_type
    {
    public:
        legacy_type(evil e)
            : e_(e)
        {}

        operator evil() const
        {
            return e_;
        }

    private:
        evil e_;
    };
}

foo.h:

#include "forward.h"

class foo
{
public:
    void f(type::type t);
};

foo.cc:

#include "foo.h"

#include <iostream>
#include "enum.h"

void foo::f(type::type t)
{
    switch (t)
    {
        case legacy::x:
            std::cout << "x" << std::endl;
            break;
        case legacy::y:
            std::cout << "y" << std::endl;
            break;
        case legacy::z:
            std::cout << "z" << std::endl;
            break;
        default:
            std::cout << "default" << std::endl;
    }
}

main.cc:

#include "foo.h"
#include "enum.h"

int main()
{
    foo fu;
    fu.f(legacy::x);

    return 0;
}

Perhatikan bahwa foo.htajuk tidak harus tahu apa-apa legacy::evil. Hanya file yang menggunakan tipe lawas legacy::evil(di sini: main.cc) yang perlu disertakan enum.h.

Solusi saya untuk masalah Anda adalah:

1 - gunakan int bukan enum: Deklarasikan int Anda di ruang nama anonim di file CPP Anda (bukan di header):

namespace
{
   const int FUNCTIONALITY_NORMAL = 0 ;
   const int FUNCTIONALITY_RESTRICTED = 1 ;
   const int FUNCTIONALITY_FOR_PROJECT_X = 2 ;
}

Karena metode Anda bersifat pribadi, tidak ada yang akan mengacaukan data. Anda bahkan dapat melangkah lebih jauh untuk menguji apakah seseorang mengirimi Anda data yang tidak valid:

namespace
{
   const int FUNCTIONALITY_begin = 0 ;
   const int FUNCTIONALITY_NORMAL = 0 ;
   const int FUNCTIONALITY_RESTRICTED = 1 ;
   const int FUNCTIONALITY_FOR_PROJECT_X = 2 ;
   const int FUNCTIONALITY_end = 3 ;

   bool isFunctionalityCorrect(int i)
   {
      return (i >= FUNCTIONALITY_begin) && (i < FUNCTIONALITY_end) ;
   }
}

2: buat kelas penuh dengan instantiations const terbatas, seperti yang dilakukan di Jawa. Teruskan mendeklarasikan kelas, dan kemudian mendefinisikannya dalam file CPP, dan hanya instanciate nilai-nilai seperti enum. Saya melakukan sesuatu seperti itu di C ++, dan hasilnya tidak memuaskan seperti yang diinginkan, karena memerlukan beberapa kode untuk mensimulasikan enum (copy konstruksi, operator =, dll).

3: Seperti yang diusulkan sebelumnya, gunakan enum yang dideklarasikan secara pribadi. Terlepas dari kenyataan bahwa pengguna akan melihat definisi lengkapnya, ia tidak akan dapat menggunakannya, atau menggunakan metode pribadi. Jadi, Anda biasanya dapat memodifikasi enum dan konten metode yang ada tanpa perlu mengkompilasi ulang kode menggunakan kelas Anda.

Dugaan saya akan menjadi solusi 3 atau 1.

Karena enum dapat menjadi ukuran integral dari berbagai ukuran (kompiler memutuskan ukuran yang dimiliki oleh enum), penunjuk ke enum juga dapat memiliki ukuran yang bervariasi, karena ini adalah tipe integral (karakter memiliki pointer dari ukuran yang berbeda pada beberapa platform). misalnya).

Jadi kompiler bahkan tidak dapat membiarkan Anda meneruskan-mendeklarasikan enum dan pengguna pointer ke sana, karena bahkan di sana, ia membutuhkan ukuran enum.

Anda menentukan enumerasi untuk membatasi nilai elemen elemen yang mungkin untuk kumpulan terbatas. Pembatasan ini harus diberlakukan pada waktu kompilasi.

Ketika meneruskan menyatakan fakta bahwa Anda akan menggunakan 'set terbatas' nanti tidak menambah nilai: kode selanjutnya perlu mengetahui nilai yang mungkin untuk mendapatkan manfaat darinya.

Meskipun compiler yang bersangkutan tentang ukuran tipe enumerasi, yang maksud dari pencacahan akan hilang ketika Anda maju menyatakan hal itu.