C
enum stuff q;
enum stuff {a, b=-4, c, d=-2, e, f=-3, g} s;
Deklarasi yang bertindak sebagai definisi tentatif dari bilangan bulat yang ditandatangani s
dengan tipe lengkap dan deklarasi yang bertindak sebagai definisi tentatif bilangan bulat yang ditandatangani q
dengan tipe tidak lengkap dalam cakupan (yang menyelesaikan ke tipe lengkap dalam lingkup karena definisi tipe hadir di mana saja di ruang lingkup) (seperti definisi tentatif, pengidentifikasi q
dan s
dapat dideklarasikan ulang dengan versi yang tidak lengkap atau lengkap dari jenis yang sama int
atau enum stuff
beberapa kali tetapi hanya didefinisikan satu kali dalam ruang lingkup yaitu int q = 3; dan hanya dapat didefinisikan ulang dalam subscope, dan hanya dapat digunakan setelah definisi). Anda juga hanya dapat menggunakan tipe lengkap enum stuff
sekali dalam lingkup karena berfungsi sebagai definisi tipe.
Definisi tipe enumerasi kompiler enum stuff
juga dibuat hadir di lingkup file (dapat digunakan sebelum dan di bawah) serta deklarasi tipe maju (tipe enum stuff
dapat memiliki beberapa deklarasi tetapi hanya satu definisi / penyelesaian dalam lingkup dan dapat didefinisikan ulang dalam subskop) . Hal ini juga bertindak sebagai direktif kompiler untuk mengganti a
dengan nilai p 0
, b
dengan -4
, c
dengan 5
, d
dengan -2
, e
dengan -3
, f
dengan -1
dan g
dengan -2
di lingkup saat ini. Konstanta enumerasi sekarang berlaku setelah definisi sampai redefinisi berikutnya dalam enum berbeda yang tidak dapat berada pada tingkat cakupan yang sama.
typedef enum bool {false, true} bool;
//this is the same as
enum bool {false, true};
typedef enum bool bool;
//or
enum bool {false, true};
typedef unsigned int bool;
//remember though, bool is an alias for _Bool if you include stdbool.h.
//and casting to a bool is the same as the !! operator
Tag namespace yang digunakan bersama oleh enum, struct dan union terpisah dan harus diawali dengan jenis kata kunci (enum, struct atau union) dalam C yaitu setelah enum a {a} b
, enum a c
harus digunakan dan tidak a c
. Karena tag namespace terpisah ke namespace pengenal, enum a {a} b
diizinkan tetapi enum a {a, b} b
bukan karena konstanta berada dalam namespace yang sama dengan pengidentifikasi variabel, namespace pengidentifikasi. typedef enum a {a,b} b
juga tidak diizinkan karena nama-typedef adalah bagian dari namespace pengenal.
Jenis enum bool
dan konstanta mengikuti pola berikut dalam C:
+--------------+-----+-----+-----+
| enum bool | a=1 |b='a'| c=3 |
+--------------+-----+-----+-----+
| unsigned int | int | int | int |
+--------------+-----+-----+-----+
+--------------+-----+-----+-----+
| enum bool | a=1 | b=-2| c=3 |
+--------------+-----+-----+-----+
| int | int | int | int |
+--------------+-----+-----+-----+
+--------------+-----+---------------+-----+
| enum bool | a=1 |b=(-)0x80000000| c=2 |
+--------------+-----+---------------+-----+
| unsigned int | int | unsigned int | int |
+--------------+-----+---------------+-----+
+--------------+-----+---------------+-----+
| enum bool | a=1 |b=(-)2147483648| c=2 |
+--------------+-----+---------------+-----+
| unsigned int | int | unsigned int | int |
+--------------+-----+---------------+-----+
+-----------+-----+---------------+------+
| enum bool | a=1 |b=(-)0x80000000| c=-2 |
+-----------+-----+---------------+------+
| long | int | long | int |
+-----------+-----+---------------+------+
+-----------+-----+---------------+------+
| enum bool | a=1 | b=2147483648 | c=-2 |
+-----------+-----+---------------+------+
| long | int | long | int |
+-----------+-----+---------------+------+
+-----------+-----+---------------+------+
| enum bool | a=1 | b=-2147483648 | c=-2 |
+-----------+-----+---------------+------+
| int | int | int | int |
+-----------+-----+---------------+------+
+---------------+-----+---------------+-----+
| enum bool | a=1 | b=99999999999 | c=1 |
+---------------+-----+---------------+-----+
| unsigned long | int | unsigned long | int |
+---------------+-----+---------------+-----+
+-----------+-----+---------------+------+
| enum bool | a=1 | b=99999999999 | c=-1 |
+-----------+-----+---------------+------+
| long | int | long | int |
+-----------+-----+---------------+------+
Ini mengkompilasi dengan baik di C:
#include <stdio.h>
enum c j;
enum c{f, m} p;
typedef int d;
typedef int c;
enum c j;
enum m {n} ;
int main() {
enum c j;
enum d{l};
enum d q;
enum m y;
printf("%llu", j);
}
C ++
Di C ++, enum dapat memiliki tipe
enum Bool: bool {True, False} Bool;
enum Bool: bool {True, False, maybe} Bool; //error
Dalam situasi ini, konstanta dan pengidentifikasi semua memiliki tipe yang sama, bool, dan kesalahan akan terjadi jika angka tidak dapat diwakili oleh tipe itu. Mungkin = 2, yang bukan bool. Juga, True, False dan Bool tidak boleh huruf kecil jika tidak akan berbenturan dengan kata kunci bahasa. Enum juga tidak dapat memiliki tipe pointer.
Aturan untuk enum berbeda dalam C ++.
#include <iostream>
c j; //not allowed, unknown type name c before enum c{f} p; line
enum c j; //not allowed, forward declaration of enum type not allowed and variable can have an incomplete type but not when it's still a forward declaration in C++ unlike C
enum c{f, m} p;
typedef int d;
typedef int c; // not allowed in C++ as it clashes with enum c, but if just int c were used then the below usages of c j; would have to be enum c j;
[enum] c j;
enum m {n} ;
int main() {
[enum] c j;
enum d{l}; //not allowed in same scope as typedef but allowed here
d q;
m y; //simple type specifier not allowed, need elaborated type specifier enum m to refer to enum m here
p v; // not allowed, need enum p to refer to enum p
std::cout << j;
}
Enum variabel dalam C ++ tidak lagi hanya unsigned integers dll, mereka juga bertipe enum dan hanya dapat diberikan konstanta dalam enum. Namun ini bisa dibuang.
#include <stdio.h>
enum a {l} c;
enum d {f} ;
int main() {
c=0; // not allowed;
c=l;
c=(a)1;
c=(enum a)4;
printf("%llu", c); //4
}
Kelas Enum
enum struct
identik dengan enum class
#include <stdio.h>
enum class a {b} c;
int main() {
printf("%llu", a::b<1) ; //not allowed
printf("%llu", (int)a::b<1) ;
printf("%llu", a::b<(a)1) ;
printf("%llu", a::b<(enum a)1);
printf("%llu", a::b<(enum class a)1) ; //not allowed
printf("%llu", b<(enum a)1); //not allowed
}
Operator resolusi ruang lingkup masih dapat digunakan untuk enum non-cakupan.
#include <stdio.h>
enum a: bool {l, w} ;
int main() {
enum a: bool {w, l} f;
printf("%llu", ::a::w);
}
Tetapi karena w tidak dapat didefinisikan sebagai sesuatu yang lain dalam ruang lingkup, tidak ada perbedaan antara ::w
dan::a::w