วิธีกำหนดประเภท enum (enum) ใน C เป็นอย่างไร

ฉันไม่แน่ใจว่าเป็นไวยากรณ์ที่เหมาะสมสำหรับการใช้ C enums อะไร ฉันมีรหัสต่อไปนี้:

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = IMMEDIATE;

แต่สิ่งนี้ไม่ได้คอมไพล์ด้วยข้อผิดพลาดต่อไปนี้:

error: conflicting types for ‘strategy’
error: previous declaration of ‘strategy’ was here

ผมทำอะไรผิดหรือเปล่า?

การประกาศตัวแปร enum ทำได้ดังนี้:

enum strategy {RANDOM, IMMEDIATE, SEARCH};
enum strategy my_strategy = IMMEDIATE;

อย่างไรก็ตามคุณสามารถใช้ a typedefเพื่อย่อการประกาศตัวแปรให้สั้นลงดังนี้:

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy my_strategy = IMMEDIATE;

มีแบบแผนการตั้งชื่อเพื่อแยกความแตกต่างระหว่างชนิดและตัวแปรเป็นความคิดที่ดี:

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy_type;
strategy_type my_strategy = IMMEDIATE;

มันคุ้มค่าที่ชี้ให้เห็นว่าคุณไม่จำเป็นต้อง typedefคุณสามารถทำมันได้ดังต่อไปนี้

enum strategy { RANDOM, IMMEDIATE, SEARCH };
enum strategy my_strategy = IMMEDIATE;

typedefมันเป็นคำถามที่รูปแบบไม่ว่าจะเป็นคุณต้องการ enum strategyโดยไม่ได้ถ้าคุณต้องการที่จะอ้างถึงประเภทการแจงนับที่คุณจำเป็นต้องใช้ ด้วยคุณสามารถพูดstrategyได้

ทั้งสองมีข้อดีและข้อเสียของพวกเขา สิ่งหนึ่งนั้นมีประโยชน์มากกว่า แต่เก็บตัวระบุประเภทไว้ในแท็ก - เนมสเปซซึ่งพวกมันจะไม่ขัดแย้งกับตัวระบุสามัญ (คิดstruct statและstatฟังก์ชั่น: สิ่งเหล่านี้จะไม่ขัดแย้งกัน) และที่คุณเห็นทันทีว่าเป็นประเภท อีกอันหนึ่งสั้นกว่า แต่นำตัวระบุชนิดมาไว้ในเนมสเปซปกติ

คุณพยายามที่จะประกาศstrategyสองครั้งและนั่นคือสาเหตุที่คุณได้รับข้อผิดพลาดด้านบน งานดังต่อไปนี้โดยไม่มีการร้องเรียนใด ๆ (รวบรวมด้วยgcc -ansi -pendantic -Wall):

#include <stdio.h>

enum { RANDOM, IMMEDIATE, SEARCH } strategy = IMMEDIATE;

int main(int argc, char** argv){
    printf("strategy: %d\n", strategy);

    return 0;
}

หากแทนที่ข้างต้นบรรทัดที่สองจะเปลี่ยนเป็น:

...
enum { RANDOM, IMMEDIATE, SEARCH } strategy;
strategy = IMMEDIATE;
...

จากคำเตือนคุณสามารถเห็นความผิดพลาดได้ง่าย:

enums.c:5:1: warning: data definition has no type or storage class [enabled by default]
enums.c:5:1: warning: type defaults to ‘int’ in declaration of ‘strategy’ [-Wimplicit-int]
enums.c:5:1: error: conflicting types for ‘strategy’
enums.c:4:36: note: previous declaration of ‘strategy’ was here

ดังนั้นคอมไพเลอร์จึงใช้strategy = IMMEDIATEสำหรับการประกาศตัวแปรที่เรียกว่าstrategyชนิดเริ่มต้นintแต่มีการประกาศตัวแปรก่อนหน้านี้ด้วยชื่อนี้แล้ว

อย่างไรก็ตามหากคุณทำการกำหนดในmain()ฟังก์ชั่นมันจะเป็นรหัสที่ถูกต้อง:

#include <stdio.h>

enum { RANDOM, IMMEDIATE, SEARCH } strategy = IMMEDIATE;

int main(int argc, char** argv){
    strategy=SEARCH;
    printf("strategy: %d\n", strategy);

    return 0;
}

เมื่อคุณพูด

enum {RANDOM, IMMEDIATE, SEARCH} strategy;

คุณสร้างตัวแปรอินสแตนซ์เดียวที่เรียกว่า 'กลยุทธ์' ของ enum นิรนาม นี่ไม่ใช่สิ่งที่มีประโยชน์มากที่ต้องทำ - คุณต้องมี typedef:

typedef enum {RANDOM, IMMEDIATE, SEARCH} StrategyType; 
StrategyType strategy = IMMEDIATE;

ตามที่เขียนไว้ไม่มีอะไรผิดปกติกับรหัสของคุณ คุณแน่ใจหรือว่ายังไม่ได้ทำอะไรบางอย่าง

int strategy;
...
enum {RANDOM, IMMEDIATE, SEARCH} strategy;

ข้อความแสดงข้อผิดพลาดชี้ไปที่บรรทัดใด เมื่อมีข้อความว่า "การประกาศก่อนหน้านี้ของ 'กลยุทธ์' อยู่ที่นี่" อะไรคือ "ที่นี่" และมันแสดงอะไร

@ThoAppelsin ในความคิดเห็นของเขาเพื่อตอบคำถามถูกต้อง ข้อมูลโค้ดที่โพสต์ในคำถามนั้นถูกต้องและไม่มีข้อผิดพลาด ข้อผิดพลาดที่คุณมีจะต้องเป็นเพราะไวยากรณ์ไม่ดีอื่น ๆ ในสถานที่อื่น ๆ ของไฟล์ต้นฉบับของคุณค enum{a,b,c};กำหนดค่าคงที่สามสัญลักษณ์ ( a, bและc) ซึ่งเป็นจำนวนเต็มมีค่า0, 1และ2ตามลำดับ แต่เมื่อเราใช้enumมันเป็นเพราะเราไม่ได้มักจะดูแลเกี่ยวกับค่าเฉพาะจำนวนเต็มเราดูแลเพิ่มเติมเกี่ยวกับความหมายของชื่อสัญลักษณ์คง หมายความว่าคุณสามารถมีสิ่งนี้:

#include <stdio.h>
enum {a,b,c};
int main(){
  printf("%d\n",b);
  return 0;
}

1และออกจะนี้

สิ่งนี้จะถูกต้อง:

#include <stdio.h>
enum {a,b,c};
int bb=b;
int main(){
  printf("%d\n",bb);
  return 0;
}

และจะส่งออกเช่นเดียวกับก่อน

หากคุณทำสิ่งนี้:

enum {a,b,c};
enum {a,b,c};

คุณจะมีข้อผิดพลาด แต่ถ้าคุณทำสิ่งนี้:

enum alfa{a,b,c};
enum alfa;

คุณจะไม่มีข้อผิดพลาด

คุณสามารถทำสิ่งนี้:

enum {a,b,c};
int aa=a;

และจะเป็นตัวแปรจำนวนเต็มมีค่าaa 0แต่คุณสามารถทำสิ่งนี้:

enum {a,b,c} aa= a;

และจะมีผลเช่นเดียวกัน (นั่นคือaaการintมี0ค่า)

คุณยังสามารถทำสิ่งนี้:

enum {a,b,c} aa= a;
aa= 7;

และaaจะมีค่าint7

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

enum tag1 {a,b,c};
enum tag1 var1= a;
enum tag1 var2= b;

การใช้typedefมันเพื่อความปลอดภัยของคุณจากการเขียนแต่ละครั้งenum tag1เพื่อกำหนดตัวแปร ด้วยtypedefคุณสามารถพิมพ์Tag1:

typedef enum {a,b,c} Tag1;
Tag1 var1= a;
Tag1 var2= b;

คุณยังสามารถ:

typedef enum tag1{a,b,c}Tag1;
Tag1 var1= a;
enum tag1 var2= b;

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

enum {A,B,C};

แทน

enum {a,b,c};

เป็นมูลค่าการกล่าวขวัญว่าใน C ++คุณสามารถใช้ "enum" เพื่อกำหนดประเภทใหม่โดยไม่ต้องใช้คำสั่ง typedef

enum Strategy {RANDOM, IMMEDIATE, SEARCH};
...
Strategy myStrategy = IMMEDIATE;

ฉันพบว่าวิธีนี้เป็นมิตรมากขึ้น

[แก้ไข - สถานะ C ++ ที่ชัดเจน - ฉันมีสิ่งนี้ในตอนแรกแล้วลบออก!]

ดูเหมือนจะมีความสับสนเกี่ยวกับการประกาศ

เมื่อstrategyมาก่อน{RANDOM, IMMEDIATE, SEARCH}ดังต่อไปนี้

enum strategy {RANDOM, IMMEDIATE, SEARCH};

คุณกำลังสร้างชื่อenum strategyใหม่ อย่างไรก็ตามเมื่อประกาศตัวแปรคุณต้องใช้enum strategyตัวเอง strategyคุณไม่สามารถเพียงแค่ใช้ ดังนั้นต่อไปนี้ไม่ถูกต้อง

enum strategy {RANDOM, IMMEDIATE, SEARCH};
strategy a;

ในขณะที่ต่อไปนี้ถูกต้อง

enum strategy {RANDOM, IMMEDIATE, SEARCH};

enum strategy queen = RANDOM;
enum strategy king = SEARCH;
enum strategy pawn[100];

เมื่อstrategyมาถึง{RANDOM, IMMEDIATE, SEARCH}คุณกำลังสร้าง enum ที่ไม่ระบุชื่อและประกาศว่าstrategyเป็นตัวแปรประเภทนั้น

ดังนั้นตอนนี้คุณสามารถทำสิ่งที่ชอบ

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = RANDOM;

อย่างไรก็ตามคุณไม่สามารถประกาศตัวแปรประเภทอื่นได้enum {RANDOM, IMMEDIATE, SEARCH}เนื่องจากคุณไม่เคยตั้งชื่อ ดังนั้นต่อไปนี้ไม่ถูกต้อง

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
enum strategy a = RANDOM;

คุณสามารถรวมคำจำกัดความทั้งสองเข้าด้วยกัน

enum strategy {RANDOM, IMMEDIATE, SEARCH} a, b;

a = RANDOM;
b = SEARCH;
enum strategy c = IMMEDIATE;

Typedef ดังที่บันทึกไว้ก่อนหน้านี้ใช้สำหรับการสร้างการประกาศตัวแปรที่สั้นกว่า

typedef enum {RANDOM, IMMEDIATE, SEARCH} strategy;

ตอนนี้คุณได้บอกคอมไพเลอร์ที่enum {RANDOM, IMMEDIATE, SEARCH}เป็นอิสระไปstrategyแล้ว ดังนั้นตอนนี้คุณสามารถใช้strategyเป็นประเภทตัวแปรได้อย่างอิสระ คุณไม่จำเป็นต้องพิมพ์enum strategyอีกต่อไป ต่อไปนี้ถูกต้องในขณะนี้

strategy x = RANDOM;

คุณยังสามารถรวม Typedef พร้อมกับชื่อ enum เพื่อรับ

typedef enum strategyName {RANDOM, IMMEDIATE, SEARCH} strategy;

การใช้วิธีนี้มีประโยชน์ไม่มากนักนอกเหนือจากความจริงที่ว่าตอนนี้คุณสามารถใช้strategyและenum strategyNameเปลี่ยนได้

typedef enum strategyName {RANDOM, IMMEDIATE, SEARCH} strategy;

enum strategyName a = RANDOM;
strategy b = SEARCH;

หากคุณประกาศชื่อสำหรับการแจงนับจะไม่มีข้อผิดพลาดเกิดขึ้น

หากไม่ได้ประกาศคุณจะต้องใช้typedef:

enum enum_name {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = IMMEDIATE;

จะไม่แสดงข้อผิดพลาด ...

สิ่งที่ฉันชอบและใช้ในการก่อสร้างอยู่เสมอคือ:

typedef enum MyBestEnum
{
    /* good enough */
    GOOD = 0,
    /* even better */
    BETTER,
    /* divine */
    BEST
};

ฉันเชื่อว่านี่จะลบปัญหาที่คุณมี การใช้รูปแบบใหม่นั้นมาจากตัวเลือกในมุมมองของฉัน

คำตอบของ Tarc นั้นดีที่สุด

การถกเถียงเรื่อง Enum ส่วนใหญ่นั้นเป็นปลาเฮอริ่งแดง

เปรียบเทียบข้อมูลโค้ดนี้: -

int strategy;
strategy = 1;   
void some_function(void) 
{
}

ซึ่งจะช่วยให้

error C2501: 'strategy' : missing storage-class or type specifiers
error C2086: 'strategy' : redefinition

กับอันนี้ที่คอมไพล์โดยไม่มีปัญหา

int strategy;
void some_function(void) 
{
    strategy = 1;   
}

ตัวแปรstrategyต้องถูกตั้งค่าไว้ที่การประกาศหรือภายในฟังก์ชั่นอื่น ๆ คุณไม่สามารถเขียนซอฟต์แวร์ตามอำเภอใจ - โดยเฉพาะการมอบหมาย - ที่ขอบเขตทั่วโลก

ความจริงที่ว่าเขาใช้ enum {RANDOM, IMMEDIATE, SEARCH} แทนที่จะเป็น int นั้นมีความเกี่ยวข้องกับระดับความสับสนที่ผู้คนไม่สามารถมองเห็นได้ ข้อความแสดงข้อผิดพลาดการกำหนดนิยามใหม่ในคำถามแสดงว่านี่คือสิ่งที่ผู้เขียนทำผิด

ดังนั้นตอนนี้คุณน่าจะเห็นได้ว่าทำไมตัวอย่างแรกด้านล่างนี้จึงผิดและอีกสามตัวนั้นไม่เป็นไร

ตัวอย่างที่ 1 ผิด!

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
strategy = IMMEDIATE;
void some_function(void) 
{
}

ตัวอย่างที่ 2

enum {RANDOM, IMMEDIATE, SEARCH} strategy = IMMEDIATE;
void some_function(void) 
{
}

ตัวอย่างที่ 3

enum {RANDOM, IMMEDIATE, SEARCH} strategy;
void some_function(void) 
{
    strategy = IMMEDIATE;
}

ตัวอย่างที่ 4

void some_function(void) 
{
    enum {RANDOM, IMMEDIATE, SEARCH} strategy;
    strategy = IMMEDIATE;
}

หากคุณมีโปรแกรมที่ใช้งานได้คุณก็สามารถวางตัวอย่างข้อมูลเหล่านี้ลงในโปรแกรมของคุณและดูว่าคอมไพล์และบางอันไม่มี

ฉันพยายามกับ gcc และเกิดขึ้นกับความต้องการของฉันฉันถูกบังคับให้ใช้ทางเลือกสุดท้ายเพื่อรวบรวมโดยไม่เกิดข้อผิดพลาด

typedef enum state {a = 0, b = 1, c = 2} สถานะ ;

typedef enum state {a = 0, b = 1, c = 2} state;

typedef enum state old; // New type, alias of the state type.
typedef enum state new; // New type, alias of the state type.

new now     = a;
old before  = b;

printf("State   now = %d \n", now);
printf("Sate before = %d \n\n", before);

ค

enum stuff q;
enum stuff {a, b=-4, c, d=-2, e, f=-3, g} s;

การประกาศที่ทำหน้าที่เป็นคำนิยามที่แน่นอนของจำนวนเต็มที่ลงนามsด้วยประเภทที่สมบูรณ์และการประกาศซึ่งทำหน้าที่เป็นคำนิยามที่แน่นอนของจำนวนเต็มที่ลงนามqด้วยประเภทที่ไม่สมบูรณ์ในขอบเขต (ซึ่งจะแก้ไขให้เป็นประเภทที่สมบูรณ์ในขอบเขต ขอบเขต) (เช่นคำจำกัดความเบื้องต้นใด ๆ ตัวระบุqและsสามารถประกาศใหม่ด้วยรุ่นที่ไม่สมบูรณ์หรือสมบูรณ์ของประเภทเดียวกันintหรือenum stuffหลายครั้ง แต่กำหนดเพียงครั้งเดียวในขอบเขตเช่น int q = 3 และสามารถกำหนดใหม่ได้ในขอบเขตย่อยเท่านั้นและ ใช้งานได้หลังจากนิยาม) นอกจากนี้คุณยังสามารถใช้ประเภทที่สมบูรณ์enum stuffเพียงครั้งเดียวในขอบเขตเพราะมันทำหน้าที่เป็นคำนิยามประเภท

คอมไพเลอร์ชนิดคำจำกัดความการแจงนับสำหรับenum stuffทำยังมีอยู่ที่ขอบเขตไฟล์ (ใช้งานก่อนและด้านล่าง) เช่นเดียวกับการประกาศประเภทไปข้างหน้า (ประเภทenum stuffสามารถมีการประกาศหลาย ๆ แต่คำจำกัดความ / ความสมบูรณ์ในขอบเขตเดียวเท่านั้น . นอกจากนี้ยังทำหน้าที่เป็นคำสั่งคอมไพเลอร์เพื่อทดแทนaกับ rvalue 0, bกับ-4, cกับ5, dกับ-2, eกับ-3, fด้วย-1และgด้วย-2ในขอบเขตปัจจุบัน ค่าคงที่การแจงนับตอนนี้ใช้หลังจากการกำหนดจนกระทั่งนิยามใหม่ต่อไปใน enum อื่นซึ่งไม่สามารถอยู่ในระดับขอบเขตเดียวกัน

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 

แท็กเนมสเปซที่ใช้ร่วมกันโดย enum, struct และ union ถูกแยกออกและจะต้องนำหน้าด้วยคีย์เวิร์ด type (enum, struct หรือ union) ใน C คือหลังจากenum a {a} bนั้นenum a cต้องใช้และไม่a cใช้ เนื่องจากแท็กเนมสเปซแยกจากเนมสเปซของตัวระบุenum a {a} bจึงได้รับอนุญาต แต่enum a {a, b} bไม่ใช่เพราะค่าคงที่อยู่ในเนมสเปซเดียวกันกับตัวระบุตัวแปรนั่นคือเนมสเปซของตัวระบุ typedef enum a {a,b} bไม่อนุญาตด้วยเนื่องจาก typedef-names เป็นส่วนหนึ่งของ namespace ของตัวระบุ

ประเภทของenum boolและค่าคงที่เป็นไปตามรูปแบบต่อไปนี้ใน 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 |
+-----------+-----+---------------+------+

รวบรวมสิ่งนี้ได้ดีใน 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 ++

ใน C ++, enums สามารถมีประเภทได้

enum Bool: bool {True, False} Bool;
enum Bool: bool {True, False, maybe} Bool; //error

ในสถานการณ์นี้ค่าคงที่และตัวระบุทั้งหมดมีชนิดเดียวกันบูลและข้อผิดพลาดจะเกิดขึ้นหากไม่สามารถแสดงตัวเลขด้วยชนิดนั้น อาจ = 2 ซึ่งไม่ใช่บูล นอกจากนี้จริงเท็จและ Bool ไม่สามารถเป็นตัวพิมพ์เล็กมิฉะนั้นพวกเขาจะปะทะกับคำหลักภาษา enum ยังไม่สามารถมีชนิดพอยน์เตอร์ได้

กฎสำหรับ enums แตกต่างกันใน 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;
}

ตัวแปร Enums ใน C ++ ไม่ได้เป็นเพียงจำนวนเต็มที่ไม่ได้ลงชื่ออีกต่อไป แต่ยังเป็น enum type และสามารถกำหนดค่าคงที่ใน enum ได้อีกด้วย อย่างไรก็ตามเรื่องนี้สามารถถูกโยนทิ้งไป

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

คลาส Enum

enum struct เหมือนกันกับ 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
}

ตัวดำเนินการแก้ไขปัญหาขอบเขตยังคงสามารถใช้สำหรับ enums ที่ไม่มีขอบเขต

#include <stdio.h>
enum a: bool {l, w} ;
int main() {
  enum a: bool {w, l} f;
  printf("%llu", ::a::w);
}

แต่เนื่องจาก w ไม่สามารถนิยามเป็นอย่างอื่นในขอบเขตจึงไม่มีความแตกต่างระหว่าง::wและ::a::w