blocks|key|1208393|text|C中的枚举是在代码中具有方便名称的数字。它们不是字符串，并且在源代码中分配给它们的名称不会编译到程序中，因此在运行时无法访问它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208394|获得所需内容的唯一方法是自己编写一个函数，将枚举值转换为字符串。例如(假设您将enum+Days的声明移到了main之外)：|offset|length|style|CODE|1208395|const+char*+getDayName(enum+Days+day)+
{
+++switch+(day)+
+++{
++++++case+Sunday:+return+"Sunday";
++++++case+Monday:+return+"Monday";
++++++/*+etc...+*/
+++}
}

/*+Then,+later+in+main:+*/
printf("%25s",+getDayName(TheDay));|code-block|syntax|javascript|1208396|或者，您可以使用数组作为映射，例如|1208397|const+char*+dayNames[]+=+{"Sunday",+"Monday",+"Tuesday",+/*+...+etc+...+*/+};

/*+...+*/

printf("%25s",+dayNames[TheDay]);|1208398|但在这里，您可能希望在枚举中指定Sunday+=+0以确保安全……我不确定C标准是否要求编译器从0开始枚举，尽管大多数都是这样(我相信有人会发表评论来确认或否认这一点)。|1208399|entityMap^0|0|13|9|1I|4|0|0|0|0|G|A|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

Enumerations in C are numbers that have convenient names inside your code. They are not strings, and the names assigned to them in the source code are not compiled into your program, and so they are not accessible at runtime.

The only way to get what you want is to write a function yourself that translates the enumeration value into a string. E.g. (assuming here that you move the declaration of <code>enum Days</code> outside of <code>main</code>):

<pre><code>const char* getDayName(enum Days day) 
{
 switch (day) 
 {
 case Sunday: return "Sunday";
 case Monday: return "Monday";
 /* etc... */
 }
}

/* Then, later in main: */
printf("%s", getDayName(TheDay));
</code></pre>

Alternatively, you could use an array as a map, e.g.

<pre><code>const char* dayNames[] = {"Sunday", "Monday", "Tuesday", /* ... etc ... */ };

/* ... */

printf("%s", dayNames[TheDay]);
</code></pre>

But here you would probably want to assign <code>Sunday = 0</code> in the enumeration to be safe... I'm not sure if the C standard requires compilers to begin enumerations from 0, although most do (I'm sure someone will comment to confirm or deny this).

blocks|key|994122|text|TheDay映射回某种整数类型。所以：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994123|printf("%25s",+TheDay);|code-block|syntax|javascript|994124|尝试将TheDay解析为字符串，并将打印出垃圾信息或崩溃。|994125|printf不是类型安全的，它相信您会将正确的值传递给它。要打印值的名称，您需要创建一些方法来将枚举值映射到字符串-要么是查找表，要么是巨大的switch语句，等等。|994126|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

TheDay maps back to some integer type. So:

<pre><code>printf("%s", TheDay);
</code></pre>

Attempts to parse TheDay as a string, and will either print out garbage or crash.

printf is not typesafe and trusts you to pass the right value to it. To print out the name of the value, you'd need to create some method for mapping the enum value to a string - either a lookup table, giant switch statement, etc.

blocks|key|994174|text|我通常这样做的方式是以相同的顺序将字符串表示存储在单独的数组中，然后使用枚举值对数组进行索引：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994175|const+char+*DayNames[]+=+{+"Sunday",+"Monday",+"Tuesday",+/*+etc+*/+};
printf("%25s",+DayNames[Sunday]);+//+prints+"Sunday"|code-block|syntax|javascript|994176|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The way I usually do this is by storing the string representations in a separate array in the same order, then indexing the array with the enum value:

<pre><code>const char *DayNames[] = { "Sunday", "Monday", "Tuesday", /* etc */ };
printf("%s", DayNames[Sunday]); // prints "Sunday"
</code></pre>

blocks|key|994219|text|C中的枚举基本上是自动排序整数值的命名列表的语法糖。也就是说，当您拥有以下代码时：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994220|int+main()
{
++++enum+Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

++++Days+TheDay+=+Monday;
}|code-block|syntax|javascript|994221|您的编译器实际上会输出以下内容：|994222|int+main()
{
++++int+TheDay+=+1;+//+Monday+is+the+second+enumeration,+hence+1.+Sunday+would+be+0.
}|994223|因此，将C枚举输出为字符串对编译器来说不是一个有意义的操作。如果您希望这些函数具有人类可读的字符串，则需要定义函数将其从枚举转换为字符串。|994224|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Enumerations in C are basically syntactical sugar for named lists of automatically-sequenced integer values. That is, when you have this code:

<pre><code>int main()
{
 enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

 Days TheDay = Monday;
}
</code></pre>

Your compiler actually spits out this:

<pre><code>int main()
{
 int TheDay = 1; // Monday is the second enumeration, hence 1. Sunday would be 0.
}
</code></pre>

Therefore, outputting a C enumeration as a string is not an operation that makes sense to the compiler. If you want to have human-readable strings for these, you will need to define functions to convert from enumerations to strings.

blocks|key|1208622|text|我使用的是这样的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208623|在EnumToString.h文件中：|1208624|#undef+DECL_ENUM_ELEMENT
#undef+DECL_ENUM_ELEMENT_VAL
#undef+DECL_ENUM_ELEMENT_STR
#undef+DECL_ENUM_ELEMENT_VAL_STR
#undef+BEGIN_ENUM
#undef+END_ENUM

#ifndef+GENERATE_ENUM_STRINGS
++++#define+DECL_ENUM_ELEMENT(+element+)+element,
++++#define+DECL_ENUM_ELEMENT_VAL(+element,+value+)+element+=+value,
++++#define+DECL_ENUM_ELEMENT_STR(+element,+descr+)+DECL_ENUM_ELEMENT(+element+)
++++#define+DECL_ENUM_ELEMENT_VAL_STR(+element,+value,+descr+)+DECL_ENUM_ELEMENT_VAL(+element,+value+)
++++#define+BEGIN_ENUM(+ENUM_NAME+)+typedef+enum+tag##ENUM_NAME
++++#define+END_ENUM(+ENUM_NAME+)+ENUM_NAME;+\
++++++++++++const+char*+GetString##ENUM_NAME(enum+tag##ENUM_NAME+index);
#else
++++#define+BEGIN_ENUM(+ENUM_NAME)+const+char+*+GetString##ENUM_NAME(+enum+tag##ENUM_NAME+index+)+{\
++++++++switch(+index+)+{+
++++#define+DECL_ENUM_ELEMENT(+element+)+case+element:+return+#element;+break;
++++#define+DECL_ENUM_ELEMENT_VAL(+element,+value+)+DECL_ENUM_ELEMENT(+element+)
++++#define+DECL_ENUM_ELEMENT_STR(+element,+descr+)+case+element:+return+descr;+break;
++++#define+DECL_ENUM_ELEMENT_VAL_STR(+element,+value,+descr+)+DECL_ENUM_ELEMENT_STR(+element,+descr+)

++++#define+END_ENUM(+ENUM_NAME+)+default:+return+"Unknown+value";+}+}+;

#endif|code-block|syntax|javascript|1208625|然后，在任何头文件中，您都可以进行枚举声明|1208626|#include+"EnumToString.h"

BEGIN_ENUM(Days)
{
++++DECL_ENUM_ELEMENT(Sunday)+//will+render+"Sunday"
++++DECL_ENUM_ELEMENT(Monday)+//will+render+"Monday"
++++DECL_ENUM_ELEMENT_STR(Tuesday,+"Tuesday+string")+//will+render+"Tuesday+string"
++++DECL_ENUM_ELEMENT(Wednesday)+//will+render+"Wednesday"
++++DECL_ENUM_ELEMENT_VAL_STR(Thursday,+500,+"Thursday+string")+//+will+render+"Thursday+string"+and+the+enum+will+have+500+as+value
++++/*+...+and+so+on+*/
}
END_ENUM(MyEnum)|1208627|然后在一个名为EnumToString.c的文件中：|1208628|#include+"enum.h"

#define+GENERATE_ENUM_STRINGS++//+Start+string+generation

#include+"enum.h"+++++++++++++

#undef+GENERATE_ENUM_STRINGS+++//+Stop+string+generation|1208629|然后在main.c中：|1208630|int+main(int+argc,+char*+argv[])
{
++++Days+TheDay+=+Monday;
++++printf(+"%25d+-+%25s\n",+TheDay,+GetStringDay(TheDay)+);+//will+print+"1+-+Monday"

++++TheDay+=+Thursday;
++++printf(+"%25d+-+%25s\n",+TheDay,+GetStringDay(TheDay)+);+//will+print+"500+-+Thursday+string"

++++return+0;
}|1208631|这将为以这种方式声明并包含在"EnumToString.c“中的任何枚举生成字符串。|1208632|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

I use something like this:

in a file "EnumToString.h":

<pre><code>#undef DECL_ENUM_ELEMENT
#undef DECL_ENUM_ELEMENT_VAL
#undef DECL_ENUM_ELEMENT_STR
#undef DECL_ENUM_ELEMENT_VAL_STR
#undef BEGIN_ENUM
#undef END_ENUM

#ifndef GENERATE_ENUM_STRINGS
 #define DECL_ENUM_ELEMENT( element ) element,
 #define DECL_ENUM_ELEMENT_VAL( element, value ) element = value,
 #define DECL_ENUM_ELEMENT_STR( element, descr ) DECL_ENUM_ELEMENT( element )
 #define DECL_ENUM_ELEMENT_VAL_STR( element, value, descr ) DECL_ENUM_ELEMENT_VAL( element, value )
 #define BEGIN_ENUM( ENUM_NAME ) typedef enum tag##ENUM_NAME
 #define END_ENUM( ENUM_NAME ) ENUM_NAME; \
 const char* GetString##ENUM_NAME(enum tag##ENUM_NAME index);
#else
 #define BEGIN_ENUM( ENUM_NAME) const char * GetString##ENUM_NAME( enum tag##ENUM_NAME index ) {\
 switch( index ) { 
 #define DECL_ENUM_ELEMENT( element ) case element: return #element; break;
 #define DECL_ENUM_ELEMENT_VAL( element, value ) DECL_ENUM_ELEMENT( element )
 #define DECL_ENUM_ELEMENT_STR( element, descr ) case element: return descr; break;
 #define DECL_ENUM_ELEMENT_VAL_STR( element, value, descr ) DECL_ENUM_ELEMENT_STR( element, descr )

 #define END_ENUM( ENUM_NAME ) default: return "Unknown value"; } } ;

#endif
</code></pre>

then in any header file you make the enum declaration, day enum.h

<pre><code>#include "EnumToString.h"

BEGIN_ENUM(Days)
{
 DECL_ENUM_ELEMENT(Sunday) //will render "Sunday"
 DECL_ENUM_ELEMENT(Monday) //will render "Monday"
 DECL_ENUM_ELEMENT_STR(Tuesday, "Tuesday string") //will render "Tuesday string"
 DECL_ENUM_ELEMENT(Wednesday) //will render "Wednesday"
 DECL_ENUM_ELEMENT_VAL_STR(Thursday, 500, "Thursday string") // will render "Thursday string" and the enum will have 500 as value
 /* ... and so on */
}
END_ENUM(MyEnum)
</code></pre>

then in a file called EnumToString.c:

<pre><code>#include "enum.h"

#define GENERATE_ENUM_STRINGS // Start string generation

#include "enum.h" 

#undef GENERATE_ENUM_STRINGS // Stop string generation
</code></pre>

then in main.c:

<pre><code>int main(int argc, char* argv[])
{
 Days TheDay = Monday;
 printf( "%d - %s\n", TheDay, GetStringDay(TheDay) ); //will print "1 - Monday"

 TheDay = Thursday;
 printf( "%d - %s\n", TheDay, GetStringDay(TheDay) ); //will print "500 - Thursday string"

 return 0;
}
</code></pre>

this will generate "automatically" the strings for any enums declared this way and included in "EnumToString.c"

blocks|key|994333|text|这里有一种使用宏的更简洁的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994334|#include+<stdio.h>
#include+<stdlib.h>

#define+DOW(X,+S)+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\
++++X(Sunday)+S+X(Monday)+S+X(Tuesday)+S+X(Wednesday)+S+X(Thursday)+S+X(Friday)+S+X(Saturday)

#define+COMMA+,

/*+declare+the+enum+*/
#define+DOW_ENUM(DOW)+DOW
enum+dow+{
++++DOW(DOW_ENUM,+COMMA)
};

/*+create+an+array+of+strings+with+the+enum+names...+*/
#define+DOW_ARR(DOW+)+[DOW]+=+#DOW
const+char+*+const+dow_str[]+=+{
++++DOW(DOW_ARR,+COMMA)
};

/*+...or+create+a+switchy+function.+*/
static+const+char+*+dowstr(int+i)
{
#define+DOW_CASE(D)+case+D:+return+#D

++++switch(i)+{
++++++++DOW(DOW_CASE,+;);
++++default:+return+NULL;
++++}
}


int+main(void)
{
++++for(int+i+=+0;+i+<+7;+i%2B%2B)
++++++++printf("[%25d]+=+«%25s»\n",+i,+dow_str[i]);
++++printf("\n");
++++for(int+i+=+0;+i+<+7;+i%2B%2B)
++++++++printf("[%25d]+=+«%25s»\n",+i,+dowstr(i));
++++return+0;
}|code-block|syntax|javascript|994335|我不确定这是不是完全可移植的黑白预处理器，但它可以和gcc一起工作。|994336|这是c99+btw，所以如果您将c99+strict插入到(the+online+compiler)+ideone中，请使用它。|offset|length|style|CODE|994337|entityMap|0|LINK|mutability|MUTABLE|url|http://ideone.com/^0|0|0|0|G|A|T|S|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@$K|12|L|13|1|14]]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Here's a cleaner way to do it with macros:

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

#define DOW(X, S) \
 X(Sunday) S X(Monday) S X(Tuesday) S X(Wednesday) S X(Thursday) S X(Friday) S X(Saturday)

#define COMMA ,

/* declare the enum */
#define DOW_ENUM(DOW) DOW
enum dow {
 DOW(DOW_ENUM, COMMA)
};

/* create an array of strings with the enum names... */
#define DOW_ARR(DOW ) [DOW] = #DOW
const char * const dow_str[] = {
 DOW(DOW_ARR, COMMA)
};

/* ...or create a switchy function. */
static const char * dowstr(int i)
{
#define DOW_CASE(D) case D: return #D

 switch(i) {
 DOW(DOW_CASE, ;);
 default: return NULL;
 }
}


int main(void)
{
 for(int i = 0; i &lt; 7; i++)
 printf("[%d] = «%s»\n", i, dow_str[i]);
 printf("\n");
 for(int i = 0; i &lt; 7; i++)
 printf("[%d] = «%s»\n", i, dowstr(i));
 return 0;
}
</code></pre>

I'm not sure that this is totally portable b/w preprocessors, but it works with gcc.

This is c99 btw, so use <code>c99 strict</code> if you plug it into <a href="http://ideone.com/" rel="nofollow noreferrer">(the online compiler) ideone</a>.

blocks|key|994360|text|我对此还不熟悉，但switch语句将防御性地工作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994361|#include+<stdio.h>

enum+mycolor;

int+main(int+argc,+const+char+*+argv[])

{
enum+Days{Sunday=1,Monday=2,Tuesday=3,Wednesday=4,Thursday=5,Friday=6,Saturday=7};

enum+Days+TheDay;


printf("Please+enter+the+day+of+the+week+(0+to+6)\n");

scanf("%25d",&TheDay);

switch+(TheDay)
+{

case+Sunday:
++++++++printf("the+selected+day+is+sunday");
++++++++break;
++++case+Monday:
++++++++printf("the+selected+day+is+monday");
++++++++break;
++++case+Tuesday:
++++++++printf("the+selected+day+is+Tuesday");
++++++++break;
++++case+Wednesday:
++++++++printf("the+selected+day+is+Wednesday");
++++++++break;
++++case+Thursday:
++++++++printf("the+selected+day+is+thursday");
++++++++break;
++++case+Friday:
++++++++printf("the+selected+day+is+friday");
++++++++break;
++++case+Saturday:
++++++++printf("the+selected+day+is+Saturaday");
++++++++break;
++++default:
++++++++break;
}

return+0;
}|code-block|syntax|javascript|994362|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

i'm new to this but a switch statement will defenitely work

<pre><code>#include &lt;stdio.h&gt;

enum mycolor;

int main(int argc, const char * argv[])

{
enum Days{Sunday=1,Monday=2,Tuesday=3,Wednesday=4,Thursday=5,Friday=6,Saturday=7};

enum Days TheDay;


printf("Please enter the day of the week (0 to 6)\n");

scanf("%d",&amp;TheDay);

switch (TheDay)
 {

case Sunday:
 printf("the selected day is sunday");
 break;
 case Monday:
 printf("the selected day is monday");
 break;
 case Tuesday:
 printf("the selected day is Tuesday");
 break;
 case Wednesday:
 printf("the selected day is Wednesday");
 break;
 case Thursday:
 printf("the selected day is thursday");
 break;
 case Friday:
 printf("the selected day is friday");
 break;
 case Saturday:
 printf("the selected day is Saturaday");
 break;
 default:
 break;
}

return 0;
}
</code></pre>

blocks|key|994394|text|我知道我来晚了，但这个怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994395|const+char*+dayNames[]+=+{+[Sunday]+=+"Sunday",+[Monday]+=+"Monday",+/*and+so+on*/+};
printf("%25s",+dayNames[Sunday]);+//+prints+"Sunday"|code-block|syntax|javascript|994396|这样，您就不必手动使enum和char*阵列保持同步。如果您像我一样，很可能稍后会更改enum，并且char*数组将打印无效的字符串。这可能不是一个普遍支持的功能。但是afaik，大多数现代的C编译器都支持这种指定的初始化风格。|offset|length|style|CODE|994397|您可以阅读有关指定初始化器here的更多信息。|994398|entityMap|0|LINK|mutability|MUTABLE|url|https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html^0|0|0|A|4|F|5|17|4|1E|5|0|D|4|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@$I|18|J|19|1|1A]]|A|$]]|$1|O|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I know I am late to the party, but how about this?

<pre><code>const char* dayNames[] = { [Sunday] = "Sunday", [Monday] = "Monday", /*and so on*/ };
printf("%s", dayNames[Sunday]); // prints "Sunday"
</code></pre>

This way, you do not have to manually keep the <code>enum</code> and the <code>char*</code> array in sync. If you are like me, chances are that you will later change the <code>enum</code>, and the <code>char*</code> array will print invalid strings.
This may not be a feature universally supported. But afaik, most of the mordern day C compilers support this designated initialier style.

You can read more about designated initializers <a href="https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html" rel="nofollow">here</a>.

blocks|key|1208776|text|我喜欢在dayNames中使用枚举。为了减少输入，我们可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208777|#define+EP(x)+[x]+=+#x++/*+ENUM+PRINT+*/

const+char*+dayNames[]+=+{+EP(Sunday),+EP(Monday)};|code-block|syntax|javascript|1208778|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I like this to have enum in the dayNames.
To reduce typing, we can do the following:

<pre><code>#define EP(x) [x] = #x /* ENUM PRINT */

const char* dayNames[] = { EP(Sunday), EP(Monday)};
</code></pre>

blocks|key|1208827|text|问题是你只想把名字写一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208828|我有一个这样的ider：|1208829|#define+__ENUM(situation,num)+\
++++int+situation+=+num;++++++++const+char+*+__##situation##_name+=+#situation;

++++const+struct+{
++++++++__ENUM(get_other_string,+-203);//using+a+__ENUM+Mirco+make+it+ease+to+write,+
++++++++__ENUM(get_negative_to_unsigned,+-204);
++++++++__ENUM(overflow,-205);
//The+following+two+line+showing+the+expanding+for+__ENUM
++++++++int+get_no_num+=+-201;++++++const+char+*+__get_no_num_name+=+"get_no_num";
++++++++int+get_float_to_int+=+-202;++++++++const+char+*+get_float_to_int_name+=+"float_to_int_name";

++++}eRevJson;
#undef+__ENUM
++++struct+sIntCharPtr+{+int+value;+const+char+*+p_name;+};
//This+function+transform+it+to+string.
++++inline+const+char+*+enumRevJsonGetString(int+num)+{
++++++++sIntCharPtr+*+ptr+=+(sIntCharPtr+*)(&eRevJson);
++++++++for+(int+i+=+0;i+<+sizeof(eRevJson)+/+sizeof(sIntCharPtr);i%2B%2B)+{
++++++++++++if+(ptr[i].value+==+num)+{
++++++++++++++++return+ptr[i].p_name;
++++++++++++}
++++++++}
++++++++return+"bad_enum_value";
++++}|code-block|syntax|javascript|1208830|它使用一个结构来插入枚举，这样打印机就可以按照每个枚举值的定义来打印字符串。|1208831|int+main(int+argc,+char+*argv[])+{++
++++int+enum_test+=+eRevJson.get_other_string;
++++printf("error+is+%25s,+number+is+%25d\n",+enumRevJsonGetString(enum_test),+enum_test);|1208832|>error+is+get_other_string,+number+is+-203|offset|length|style|CODE|1208833|与枚举的不同之处在于，如果数字重复，则构建器无法报告错误。如果你不喜欢写数字，__LINE__可以替换它：|1208834|#define+____LINE__+__LINE__
#define+__ENUM(situation)+\
++++int+situation+=+(____LINE__+-+__BASELINE+-2);+++++++const+char+*+__##situation##_name+=+#situation;
constexpr+int+__BASELINE+=+__LINE__;
constexpr+struct+{
++++__ENUM(Sunday);
++++__ENUM(Monday);
++++__ENUM(Tuesday);
++++__ENUM(Wednesday);
++++__ENUM(Thursday);
++++__ENUM(Friday);
++++__ENUM(Saturday);
}eDays;
#undef+__ENUM
inline+const+char+*+enumDaysGetString(int+num)+{
++++sIntCharPtr+*+ptr+=+(sIntCharPtr+*)(&eDays);
++++for+(int+i+=+0;i+<+sizeof(eDays)+/+sizeof(sIntCharPtr);i%2B%2B)+{
++++++++if+(ptr[i].value+==+num)+{
++++++++++++return+ptr[i].p_name;
++++++++}
++++}
++++return+"bad_enum_value";
}
int+main(int+argc,+char+*argv[])+{++
++++int+d+=+eDays.Wednesday;
++++printf("day+%25s,+number+is+%25d\n",+enumDaysGetString(d),+d);
++++d+=+1;
++++printf("day+%25s,+number+is+%25d\n",+enumDaysGetString(d),+d);
}|1208835|>day+Wednesday,+number+is+3+>day+Monday,+number+is+1|1208836|entityMap^0|0|0|0|0|0|0|16|0|13|8|0|0|0|R|S|O|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@$O|16|P|17|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@$O|19|P|1A|Q|R]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1C|8|@$O|1D|P|1E|Q|R]|$O|1F|P|1G|Q|R]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|Z|$]]

The question is you want write the name just one times. 
I have an ider like this: 

<pre class="lang-cpp prettyprint-override"><code>#define __ENUM(situation,num) \
 int situation = num; const char * __##situation##_name = #situation;

 const struct {
 __ENUM(get_other_string, -203);//using a __ENUM Mirco make it ease to write, 
 __ENUM(get_negative_to_unsigned, -204);
 __ENUM(overflow,-205);
//The following two line showing the expanding for __ENUM
 int get_no_num = -201; const char * __get_no_num_name = "get_no_num";
 int get_float_to_int = -202; const char * get_float_to_int_name = "float_to_int_name";

 }eRevJson;
#undef __ENUM
 struct sIntCharPtr { int value; const char * p_name; };
//This function transform it to string.
 inline const char * enumRevJsonGetString(int num) {
 sIntCharPtr * ptr = (sIntCharPtr *)(&amp;eRevJson);
 for (int i = 0;i &lt; sizeof(eRevJson) / sizeof(sIntCharPtr);i++) {
 if (ptr[i].value == num) {
 return ptr[i].p_name;
 }
 }
 return "bad_enum_value";
 }
</code></pre>

it uses a struct to insert enum, so that a printer to string could follows each enum value define.

<pre class="lang-cpp prettyprint-override"><code>int main(int argc, char *argv[]) { 
 int enum_test = eRevJson.get_other_string;
 printf("error is %s, number is %d\n", enumRevJsonGetString(enum_test), enum_test);
</code></pre>

<code>&gt;error is get_other_string, number is -203</code> 

The difference to enum is builder can not report error if the numbers are repeated.
if you don't like write number, <code>__LINE__</code> could replace it:

<pre class="lang-cpp prettyprint-override"><code>#define ____LINE__ __LINE__
#define __ENUM(situation) \
 int situation = (____LINE__ - __BASELINE -2); const char * __##situation##_name = #situation;
constexpr int __BASELINE = __LINE__;
constexpr struct {
 __ENUM(Sunday);
 __ENUM(Monday);
 __ENUM(Tuesday);
 __ENUM(Wednesday);
 __ENUM(Thursday);
 __ENUM(Friday);
 __ENUM(Saturday);
}eDays;
#undef __ENUM
inline const char * enumDaysGetString(int num) {
 sIntCharPtr * ptr = (sIntCharPtr *)(&amp;eDays);
 for (int i = 0;i &lt; sizeof(eDays) / sizeof(sIntCharPtr);i++) {
 if (ptr[i].value == num) {
 return ptr[i].p_name;
 }
 }
 return "bad_enum_value";
}
int main(int argc, char *argv[]) { 
 int d = eDays.Wednesday;
 printf("day %s, number is %d\n", enumDaysGetString(d), d);
 d = 1;
 printf("day %s, number is %d\n", enumDaysGetString(d), d);
}
</code></pre>

<code>&gt;day Wednesday, number is 3</code> <code>&gt;day Monday, number is 1</code>

blocks|key|994608|text|还有另一种解决方案:创建自己的动态枚举类。意味着您有一个struct和一些函数来创建一个新的枚举，该枚举将元素存储在struct中，并且每个元素都有一个名称字符串。你还需要一些类型来存储单个元素，函数来比较它们等等。下面是一个示例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|994609|#include+<stdarg.h>
#include+<stdbool.h>
#include+<stddef.h>
#include+<stdio.h>
#include+<stdlib.h>
#include+<string.h>


struct+Enumeration_element_T
{
++size_t+index;
++struct+Enumeration_T+*parent;
++char+*name;
};

struct+Enumeration_T
{
++size_t+len;
++struct+Enumeration_element_T+elements[];
};
++


void+enumeration_delete(struct+Enumeration_T+*self)
{
++if(self)
++{
++++while(self->len--)
++++{
++++++free(self->elements[self->len].name);
++++}
++++free(self);
++}
}

struct+Enumeration_T+*enumeration_create(size_t+len,...)
{
++//We+do+not+check+for+size_t+overflows,+but+we+should.
++struct+Enumeration_T+*self=malloc(sizeof(self)%2Bsizeof(self->elements[0])*len);
++if(!self)
++{
++++return+NULL;
++}
++self->len=0;
++va_list+l;+
++va_start(l,len);
++for(size_t+i=0;i<len;i%2B%2B)
++{
++++const+char+*name=va_arg(l,const+char+*);
++++self->elements[i].name=malloc(strlen(name)%2B1);
++++if(!self->elements[i].name)
++++{
++++++enumeration_delete(self);
++++++return+NULL;
++++}
++++strcpy(self->elements[i].name,name);
++++self->len%2B%2B;
++}
++return+self;
}


bool+enumeration_isEqual(struct+Enumeration_element_T+*a,struct+Enumeration_element_T+*b)
{
++return+a->parent==b->parent+&&+a->index==b->index;
}

bool+enumeration_isName(struct+Enumeration_element_T+*a,+const+char+*name)
{
++return+!strcmp(a->name,name);
}

const+char+*enumeration_getName(struct+Enumeration_element_T+*a)
{
++return+a->name;
}

struct+Enumeration_element_T+*enumeration_getFromName(struct+Enumeration_T+*self,+const+char+*name)
{
++for(size_t+i=0;i<self->len;i%2B%2B)
++{
++++if(enumeration_isName(&self->elements[i],name))
++++{
++++++return+&self->elements[i];
++++}
++}
++return+NULL;
}
++
struct+Enumeration_element_T+*enumeration_get(struct+Enumeration_T+*self,+size_t+index)
{
++return+&self->elements[index];
}

size_t+enumeration_getCount(struct+Enumeration_T+*self)
{
++return+self->len;
}

bool+enumeration_isInRange(struct+Enumeration_T+*self,+size_t+index)
{
++return+index<self->len;
}



int+main(void)
{
++struct+Enumeration_T+*weekdays=enumeration_create(7,"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday");
++if(!weekdays)
++{
++++return+1;
++}
++++
++printf("Please+enter+the+day+of+the+week+(0+to+6)\n");
++size_t+j+=+0;
++if(scanf("%25zu",&j)!=1)
++{
++++enumeration_delete(weekdays);
++++return+1;
++}
++//+j=j%25enumeration_getCount(weekdays);+//alternative+way+to+make+sure+j+is+in+range
++if(!enumeration_isInRange(weekdays,j))
++{
++++enumeration_delete(weekdays);
++++return+1;
++}

++struct+Enumeration_element_T+*day=enumeration_get(weekdays,j);
++

++printf("%25s\n",enumeration_getName(day));
++
++enumeration_delete(weekdays);

++return+0;
}|code-block|syntax|javascript|994610|枚举的功能应该在它们自己的翻译单元中，但为了简单起见，我在这里将它们组合在一起。|994611|优点是这种解决方案很灵活，遵循DRY原则，您可以将信息与每个元素一起存储，可以在运行时创建新的枚举，并且可以在运行时添加新的元素。缺点是这很复杂，需要动态内存分配，不能在switch-case中使用，需要更多内存并且速度较慢。问题是，在需要高级语言的情况下，是否不应该使用高级语言。|994612|entityMap^0|S|6|1M|6|0|0|0|2D|6|2K|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

There is another solution: Create your own dynamic enumeration class. Means you have a <code>struct</code> and some function to create a new enumeration, which stores the elements in a <code>struct</code> and each element has a string for the name. You also need some type to store a individual elements, functions to compare them and so on.
Here is an example:
<pre><code>#include &lt;stdarg.h&gt;
#include &lt;stdbool.h&gt;
#include &lt;stddef.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;


struct Enumeration_element_T
{
 size_t index;
 struct Enumeration_T *parent;
 char *name;
};

struct Enumeration_T
{
 size_t len;
 struct Enumeration_element_T elements[];
};
 


void enumeration_delete(struct Enumeration_T *self)
{
 if(self)
 {
 while(self-&gt;len--)
 {
 free(self-&gt;elements[self-&gt;len].name);
 }
 free(self);
 }
}

struct Enumeration_T *enumeration_create(size_t len,...)
{
 //We do not check for size_t overflows, but we should.
 struct Enumeration_T *self=malloc(sizeof(self)+sizeof(self-&gt;elements[0])*len);
 if(!self)
 {
 return NULL;
 }
 self-&gt;len=0;
 va_list l; 
 va_start(l,len);
 for(size_t i=0;i&lt;len;i++)
 {
 const char *name=va_arg(l,const char *);
 self-&gt;elements[i].name=malloc(strlen(name)+1);
 if(!self-&gt;elements[i].name)
 {
 enumeration_delete(self);
 return NULL;
 }
 strcpy(self-&gt;elements[i].name,name);
 self-&gt;len++;
 }
 return self;
}


bool enumeration_isEqual(struct Enumeration_element_T *a,struct Enumeration_element_T *b)
{
 return a-&gt;parent==b-&gt;parent &amp;&amp; a-&gt;index==b-&gt;index;
}

bool enumeration_isName(struct Enumeration_element_T *a, const char *name)
{
 return !strcmp(a-&gt;name,name);
}

const char *enumeration_getName(struct Enumeration_element_T *a)
{
 return a-&gt;name;
}

struct Enumeration_element_T *enumeration_getFromName(struct Enumeration_T *self, const char *name)
{
 for(size_t i=0;i&lt;self-&gt;len;i++)
 {
 if(enumeration_isName(&amp;self-&gt;elements[i],name))
 {
 return &amp;self-&gt;elements[i];
 }
 }
 return NULL;
}
 
struct Enumeration_element_T *enumeration_get(struct Enumeration_T *self, size_t index)
{
 return &amp;self-&gt;elements[index];
}

size_t enumeration_getCount(struct Enumeration_T *self)
{
 return self-&gt;len;
}

bool enumeration_isInRange(struct Enumeration_T *self, size_t index)
{
 return index&lt;self-&gt;len;
}



int main(void)
{
 struct Enumeration_T *weekdays=enumeration_create(7,&quot;Sunday&quot;,&quot;Monday&quot;,&quot;Tuesday&quot;,&quot;Wednesday&quot;,&quot;Thursday&quot;,&quot;Friday&quot;,&quot;Saturday&quot;);
 if(!weekdays)
 {
 return 1;
 }
 
 printf(&quot;Please enter the day of the week (0 to 6)\n&quot;);
 size_t j = 0;
 if(scanf(&quot;%zu&quot;,&amp;j)!=1)
 {
 enumeration_delete(weekdays);
 return 1;
 }
 // j=j%enumeration_getCount(weekdays); //alternative way to make sure j is in range
 if(!enumeration_isInRange(weekdays,j))
 {
 enumeration_delete(weekdays);
 return 1;
 }

 struct Enumeration_element_T *day=enumeration_get(weekdays,j);
 

 printf(&quot;%s\n&quot;,enumeration_getName(day));
 
 enumeration_delete(weekdays);

 return 0;
}
</code></pre>
The functions of enumeration should be in their own translation unit, but i combined them here to make it simpler.
The advantage is that this solution is flexible, follows the DRY principle, you can store information along with each element, you can create new enumerations during runtime and you can add new elements during runtime.
The disadvantage is that this is complex, needs dynamic memory allocation, can't be used in <code>switch</code>-<code>case</code>, needs more memory and is slower. The question is if you should not use a higher level language in cases where you need this.

blocks|key|1208973|text|使用宏和字符串运算符(#)，我们可以实现这一点……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208974|#include+<stdio.h>
typedef+enum
{
++++MON=0,
++++TUE
}week;
int+main()
{
++++#define+printt(data)++++++++printf("%25s",#data);
++++printt(MON);
++++return+0;
}|code-block|syntax|javascript|1208975|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Using a Macro and stringize operator(#) we can achieve this....
<pre><code>#include &lt;stdio.h&gt;
typedef enum
{
 MON=0,
 TUE
}week;
int main()
{
 #define printt(data) printf(&quot;%s&quot;,#data);
 printt(MON);
 return 0;
}
</code></pre>

<pre><code>int main()
{

 enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

 Days TheDay;

 int j = 0;

 printf("Please enter the day of the week (0 to 6)\n");

 scanf("%d",&amp;j);

 TheDay = Days(j);

 //how to PRINT THE VALUES stored in TheDay

 printf("%s",TheDay); // isnt working

 return 0;
}
</code></pre>

Print text instead of value from C enum

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

int main(){  enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};  Days TheDay;  int j = 0;  printf("Please enter the day of the week (0 to 6)\n...

问打印文本而不是C枚举中的值
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问打印文本而不是C枚举中的值EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问打印文本而不是C枚举中的值
EN