blocks|key|1522126|text|没有内置的解决方案。最简单的方法是使用char*数组，其中枚举的int值索引到包含该枚举的描述性名称的字符串。如果您有一个稀疏enum+(不是从0开始或者编号中有间隙)，其中一些int映射足够高，使得基于数组的映射不切实际，那么您可以改用哈希表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1522127|entityMap^0|J|5|1R|4|2H|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

There's no built-in solution. The easiest way is with an array of <code>char*</code> where the enum's int value indexes to a string containing the descriptive name of that enum. If you have a sparse <code>enum</code> (one that doesn't start at 0 or has gaps in the numbering) where some of the <code>int</code> mappings are high enough to make an array-based mapping impractical then you could use a hash table instead.

blocks|key|1522175|text|如果枚举索引是从0开始的，则可以将名称放入char*数组中，并使用枚举值对其进行索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522176|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If the enum index is 0-based, you can put the names in an array of char*, and index them with the enum value.

blocks|key|1737254|text|试试Converting+C%2B%2B+enums+to+strings。comments有一些改进，可以解决枚举项具有任意值时的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1737255|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/KB/cpp/C___enums_to_strings.aspx|1|http://www.codeproject.com/KB/cpp/C___enums_to_strings.aspx?fid=184894&tid=1139776^0|2|V|0|Y|8|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Try <a href="http://www.codeproject.com/KB/cpp/C___enums_to_strings.aspx" rel="nofollow noreferrer">Converting C++ enums to strings</a>. The <a href="http://www.codeproject.com/KB/cpp/C___enums_to_strings.aspx?fid=184894&amp;tid=1139776" rel="nofollow noreferrer">comments</a> have improvements that solve the problem when enum items have arbitrary values.

blocks|key|1522277|text|C或C%2B%2B不提供此功能，尽管我经常需要它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522278|以下代码可以工作，尽管它最适合非稀疏枚举。|1522279|typedef+enum+{+ONE,+TWO,+THREE+}+Numbers;
char+*strNumbers[]+=+{"one","two","three"};
printf+("Value+for+TWO+is+%25s\n",strNumbers[TWO]);|code-block|syntax|javascript|1522280|我所说的非稀疏，不是指|1522281|typedef+enum+{+ONE,+FOUR_THOUSAND+=+4000+}+Numbers;|1522282|因为这里面有很大的差距。|1522283|这种方法的优点是它将枚举和字符串的定义放在一起；在函数中使用switch语句可以指定它们。这意味着你不太可能改变其中一个而不改变另一个。|1522284|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

C or C++ does not provide this functionality, although I've needed it often.

The following code works, although it's best suited for non-sparse enums.

<pre><code>typedef enum { ONE, TWO, THREE } Numbers;
char *strNumbers[] = {"one","two","three"};
printf ("Value for TWO is %s\n",strNumbers[TWO]);
</code></pre>

By non-sparse, I mean not of the form

<pre><code>typedef enum { ONE, FOUR_THOUSAND = 4000 } Numbers;
</code></pre>

since that has huge gaps in it.

The advantage of this method is that it put the definitions of the enums and strings near each other; having a switch statement in a function spearates them. This means you're less likely to change one without the other.

blocks|key|1737328|text|//+Define+your+enumeration+like+this+(in+say+numbers.h);
ENUM_BEGIN(+Numbers+)
++++ENUM(ONE),
++++ENUM(TWO),
++++ENUM(FOUR)
ENUM_END(+Numbers+)

//+The+macros+are+defined+in+a+more+fundamental+.h+file+(say+defs.h);
#define+ENUM_BEGIN(typ)+enum+typ+{
#define+ENUM(nam)+nam
#define+ENUM_END(typ)+};

//+Now+in+one+and+only+one+.c+file,+redefine+the+ENUM+macros+and+reinclude
//++the+numbers.h+file+to+build+a+string+table
#undef+ENUM_BEGIN
#undef+ENUM
#undef+ENUM_END
#define+ENUM_BEGIN(typ)+const+char+*+typ+##+_name_table+[]+=+{
#define+ENUM(nam)+#nam
#define+ENUM_END(typ)+};
#undef+NUMBERS_H_INCLUDED+++//+whatever+you+need+to+do+to+enable+reinclusion
#include+"numbers.h"

//+Now+you+can+do+exactly+what+you+want+to+do,+with+no+retyping,+and+for+any
//++number+of+enumerated+types+defined+with+the+ENUM+macro+family
//++Your+code+follows;
char+num_str[10];
int+process_numbers_str(Numbers+num)+{
++switch(num)+{
++++case+ONE:
++++case+TWO:
++++case+THREE:
++++{
++++++strcpy(num_str,+Numbers_name_table[num]);+//+eg+TWO+->+"TWO"
++++}+break;
++++default:
++++++return+0;+//no+match
++return+1;
}

//+Sweet+no+?+After+being+frustrated+by+this+for+years,+I+finally+came+up
//++with+this+solution+for+my+most+recent+project+and+plan+to+reuse+the+idea
//++forever|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1737329|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// Define your enumeration like this (in say numbers.h);
ENUM_BEGIN( Numbers )
 ENUM(ONE),
 ENUM(TWO),
 ENUM(FOUR)
ENUM_END( Numbers )

// The macros are defined in a more fundamental .h file (say defs.h);
#define ENUM_BEGIN(typ) enum typ {
#define ENUM(nam) nam
#define ENUM_END(typ) };

// Now in one and only one .c file, redefine the ENUM macros and reinclude
// the numbers.h file to build a string table
#undef ENUM_BEGIN
#undef ENUM
#undef ENUM_END
#define ENUM_BEGIN(typ) const char * typ ## _name_table [] = {
#define ENUM(nam) #nam
#define ENUM_END(typ) };
#undef NUMBERS_H_INCLUDED // whatever you need to do to enable reinclusion
#include "numbers.h"

// Now you can do exactly what you want to do, with no retyping, and for any
// number of enumerated types defined with the ENUM macro family
// Your code follows;
char num_str[10];
int process_numbers_str(Numbers num) {
 switch(num) {
 case ONE:
 case TWO:
 case THREE:
 {
 strcpy(num_str, Numbers_name_table[num]); // eg TWO -&gt; "TWO"
 } break;
 default:
 return 0; //no match
 return 1;
}

// Sweet no ? After being frustrated by this for years, I finally came up
// with this solution for my most recent project and plan to reuse the idea
// forever
</code></pre>

blocks|key|1737333|text|Making+something+both+a+C+identifier+and+a+string|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1737334|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/126277/making-something-both-a-c-identifier-and-a-string^0|0|1D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="https://stackoverflow.com/questions/126277/making-something-both-a-c-identifier-and-a-string">Making something both a C identifier and a string</a>

blocks|key|1522427|text|当然有一种方法可以做到这一点--使用X()+macros。这些宏使用C预处理器从源数据列表构造枚举、数组和代码块。您只需向包含X()宏的#define中添加新项。switch语句将自动展开。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1522428|你的例子可以写成如下：|1522429|+//+Source+data+--+Enum,+String
+#define+X_NUMBERS+\
++++X(ONE,+++"one")+\
++++X(TWO,+++"two")+\
++++X(THREE,+"three")

+...

+//+Use+preprocessor+to+create+the+Enum
+typedef+enum+{
++#define+X(Enum,+String)+++++++Enum,
+++X_NUMBERS
++#undef+X
+}+Numbers;

+...

+//+Use+Preprocessor+to+expand+data+into+switch+statement+cases
+switch(num)
+{
+#define+X(Enum,+String)+\
+++++case+Enum:++strcpy(num_str,+String);+break;
+X_NUMBERS
+#undef+X

+++++default:+return+0;+break;
+}
+return+1;|code-block|syntax|javascript|1522430|还有更有效的方法(即使用X宏来创建字符串数组和枚举索引)，但这是最简单的演示。|1522431|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ddj.com/cpp/184401387^0|I|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

There is definitely a way to do this -- use <a href="http://www.ddj.com/cpp/184401387" rel="noreferrer">X() macros</a>. These macros use the C preprocessor to construct enums, arrays and code blocks from a list of source data. You only need to add new items to the #define containing the X() macro. The switch statement would expand automatically.

Your example can be written as follows:

<pre><code> // Source data -- Enum, String
 #define X_NUMBERS \
 X(ONE, "one") \
 X(TWO, "two") \
 X(THREE, "three")

 ...

 // Use preprocessor to create the Enum
 typedef enum {
 #define X(Enum, String) Enum,
 X_NUMBERS
 #undef X
 } Numbers;

 ...

 // Use Preprocessor to expand data into switch statement cases
 switch(num)
 {
 #define X(Enum, String) \
 case Enum: strcpy(num_str, String); break;
 X_NUMBERS
 #undef X

 default: return 0; break;
 }
 return 1;
</code></pre>

There are more efficient ways (i.e. using X Macros to create an string array and enum index), but this is the simplest demo.

blocks|key|1737501|text|我知道你有几个很好的可靠答案，但是你知道C预处理器中的#运算符吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737502|它可以让你这样做：|1737503|#define+MACROSTR(k)+#k

typedef+enum+{
++++kZero,
++++kOne,
++++kTwo,
++++kThree
}+kConst;

static+char+*kConstStr[]+=+{
++++MACROSTR(kZero),
++++MACROSTR(kOne),
++++MACROSTR(kTwo),
++++MACROSTR(kThree)
};

static+void+kConstPrinter(kConst+k)
{
++++printf("%25s",+kConstStr[k]);
}|code-block|syntax|javascript|1737504|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I know you have a couple good solid answers, but do you know about the # operator in the C preprocessor?

It lets you do this:

<pre><code>#define MACROSTR(k) #k

typedef enum {
 kZero,
 kOne,
 kTwo,
 kThree
} kConst;

static char *kConstStr[] = {
 MACROSTR(kZero),
 MACROSTR(kOne),
 MACROSTR(kTwo),
 MACROSTR(kThree)
};

static void kConstPrinter(kConst k)
{
 printf("%s", kConstStr[k]);
}
</code></pre>

blocks|key|1737610|text|这里可以使用来自Making+something+both+a+C+identifier+and+a+string?的技术。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1737611|与通常的预处理器一样，编写和理解预处理器部分可能很难，包括将宏传递给其他宏，还涉及使用#和##操作符，但使用它确实很容易。我发现这种风格对于长枚举非常有用，在长枚举中，维护相同的列表两次可能真的很麻烦。|1737612|工厂代码-只键入一次，通常隐藏在标题中：|1737613|枚举Factory.h：|1737614|//+expansion+macro+for+enum+value+definition
#define+ENUM_VALUE(name,assign)+name+assign,

//+expansion+macro+for+enum+to+string+conversion
#define+ENUM_CASE(name,assign)+case+name:+return+#name;

//+expansion+macro+for+string+to+enum+conversion
#define+ENUM_STRCMP(name,assign)+if+(!strcmp(str,#name))+return+name;

///+declare+the+access+function+and+define+enum+values
#define+DECLARE_ENUM(EnumType,ENUM_DEF)+\
++enum+EnumType+{+\
++++ENUM_DEF(ENUM_VALUE)+\
++};+\
++const+char+*GetString(EnumType+dummy);+\
++EnumType+Get##EnumType##Value(const+char+*string);+\

///+define+the+access+function+names
#define+DEFINE_ENUM(EnumType,ENUM_DEF)+\
++const+char+*GetString(EnumType+value)+\
++{+\
++++switch(value)+\
++++{+\
++++++ENUM_DEF(ENUM_CASE)+\
++++++default:+return+"";+/*+handle+input+error+*/+\
++++}+\
++}+\
++EnumType+Get##EnumType##Value(const+char+*str)+\
++{+\
++++ENUM_DEF(ENUM_STRCMP)+\
++++return+(EnumType)0;+/*+handle+input+error+*/+\
++}+\|code-block|syntax|javascript|1737615|工厂使用|1737616|某些Enum.h：|1737617|#include+"enumFactory.h"
#define+SOME_ENUM(XX)+\
++++XX(FirstValue,)+\
++++XX(SecondValue,)+\
++++XX(SomeOtherValue,=50)+\
++++XX(OneMoreValue,=100)+\

DECLARE_ENUM(SomeEnum,SOME_ENUM)|1737618|someEnum.cpp：|1737619|#include+"someEnum.h"
DEFINE_ENUM(SomeEnum,SOME_ENUM)|1737620|该技术可以很容易地扩展，以便XX宏接受更多的参数，并且您还可以准备更多的宏来替换XX以满足不同的需求，类似于我在本示例中提供的三个宏。|1737621|与使用#include+/+#define+/+#undef的X-Macros的比较|1737622|虽然这与其他人提到的X-Macros类似，但我认为这个解决方案更优雅，因为它不需要#undefing任何东西，这允许你隐藏更多复杂的东西在工厂头文件-当你需要定义一个新的枚举时，头文件是你根本不会接触的东西，因此新的枚举定义要短得多，更干净。|1737623|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/126277/making-something-both-a-c-identifier-and-a-string^0|8|1E|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@$A|1D|B|1E|1|1F]]|C|$]]|$1|D|3|E|5|6|7|1G|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1H|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|1I|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1J|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1K|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|C|$]]|$1|S|3|T|5|L|7|1M|8|@]|9|@]|C|$M|N]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|C|$]]|$1|W|3|X|5|L|7|1O|8|@]|9|@]|C|$M|N]]|$1|Y|3|Z|5|6|7|1P|8|@]|9|@]|C|$]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|12|3|13|5|6|7|1R|8|@]|9|@]|C|$]]|$1|14|3|-4|5|6|7|1S|8|@]|9|@]|C|$]]]|15|$16|$5|17|18|19|C|$1A|1B]]]]

The technique from <a href="https://stackoverflow.com/questions/126277/making-something-both-a-c-identifier-and-a-string">Making something both a C identifier and a string?</a> can be used here.

As usual with such preprocessor stuff, writing and understanding the preprocessor part can be hard, and includes passing macros to other macros and involves using # and ## operators, but using it is real easy. I find this style very useful for long enums, where maintaining the same list twice can be really troublesome.

<h2>Factory code - typed only once, usually hidden in the header:</h2>

enumFactory.h:

<pre><code>// expansion macro for enum value definition
#define ENUM_VALUE(name,assign) name assign,

// expansion macro for enum to string conversion
#define ENUM_CASE(name,assign) case name: return #name;

// expansion macro for string to enum conversion
#define ENUM_STRCMP(name,assign) if (!strcmp(str,#name)) return name;

/// declare the access function and define enum values
#define DECLARE_ENUM(EnumType,ENUM_DEF) \
 enum EnumType { \
 ENUM_DEF(ENUM_VALUE) \
 }; \
 const char *GetString(EnumType dummy); \
 EnumType Get##EnumType##Value(const char *string); \

/// define the access function names
#define DEFINE_ENUM(EnumType,ENUM_DEF) \
 const char *GetString(EnumType value) \
 { \
 switch(value) \
 { \
 ENUM_DEF(ENUM_CASE) \
 default: return ""; /* handle input error */ \
 } \
 } \
 EnumType Get##EnumType##Value(const char *str) \
 { \
 ENUM_DEF(ENUM_STRCMP) \
 return (EnumType)0; /* handle input error */ \
 } \
</code></pre>

<h2>Factory used</h2>

someEnum.h:

<pre><code>#include "enumFactory.h"
#define SOME_ENUM(XX) \
 XX(FirstValue,) \
 XX(SecondValue,) \
 XX(SomeOtherValue,=50) \
 XX(OneMoreValue,=100) \

DECLARE_ENUM(SomeEnum,SOME_ENUM)
</code></pre>

someEnum.cpp:

<pre><code>#include "someEnum.h"
DEFINE_ENUM(SomeEnum,SOME_ENUM)
</code></pre>

The technique can be easily extended so that XX macros accepts more arguments, and you can also have prepared more macros to substitute for XX for different needs, similar to the three I have provided in this sample.

<h2>Comparison to X-Macros using #include / #define / #undef</h2>

While this is similar to X-Macros others have mentioned, I think this solution is more elegant in that it does not require #undefing anything, which allows you to hide more of the complicated stuff is in the factory the header file - the header file is something you are not touching at all when you need to define a new enum, therefore new enum definition is a lot shorter and cleaner.

blocks|key|1522662|text|接吻。您将对枚举执行各种其他开关/大小写操作，那么为什么打印应该有所不同呢？在打印例程中忘记大小写并不是什么大问题，考虑到有大约100个其他地方可以忘记大小写。只需编译-Wall，它将警告非详尽的大小写匹配。不要使用"default“，因为这会使开关变得详尽，并且不会收到警告。相反，让交换机退出并处理默认情况，如下所示...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522663|const+char+*myenum_str(myenum+e)
{
++++switch(e)+{
++++case+ONE:+return+"one";
++++case+TWO:+return+"two";
++++}
++++return+"invalid";
}|code-block|syntax|javascript|1522664|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|$]]

KISS. You will be doing all sorts of other switch/case things with your enums so why should printing be different? Forgetting a case in your print routine isn't a huge deal when you consider there are about 100 other places you can forget a case. Just compile -Wall, which will warn of non-exhaustive case matches. Don't use "default" because that will make the switch exhaustive and you wont get warnings. Instead, let the switch exit and deal with the default case like so...

<pre><code>const char *myenum_str(myenum e)
{
 switch(e) {
 case ONE: return "one";
 case TWO: return "two";
 }
 return "invalid";
}
</code></pre>

blocks|key|1737743|text|使用boost::preprocessor可以实现一个优雅的解决方案，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1737744|步骤1:包含头文件：|1737745|#include+"EnumUtilities.h"|code-block|syntax|javascript|1737746|步骤2:使用以下语法声明枚举对象：|1737747|MakeEnum(+TestData,
+++++++++(x)
+++++++++(y)
+++++++++(z)
+++++++++);|1737748|第三步:使用你的数据：|1737749|获取元素的数量：|1737750|td::cout+<<+"Number+of+Elements:+"+<<+TestDataCount+<<+std::endl;|1737751|获取关联的字符串：|1737752|std::cout+<<+"Value+of+"+<<+TestData2String(x)+<<+"+is+"+<<+x+<<+std::endl;
std::cout+<<+"Value+of+"+<<+TestData2String(y)+<<+"+is+"+<<+y+<<+std::endl;
std::cout+<<+"Value+of+"+<<+TestData2String(z)+<<+"+is+"+<<+z+<<+std::endl;|1737753|从关联的字符串中获取枚举值：|1737754|std::cout+<<+"Value+of+x+is+"+<<+TestData2Enum("x")+<<+std::endl;
std::cout+<<+"Value+of+y+is+"+<<+TestData2Enum("y")+<<+std::endl;
std::cout+<<+"Value+of+z+is+"+<<+TestData2Enum("z")+<<+std::endl;|1737755|这看起来干净紧凑，没有额外的文件需要包含。我在EnumUtilties.h中编写的代码如下：|1737756|#include+<boost/preprocessor/seq/for_each.hpp>
#include+<string>

#define+REALLY_MAKE_STRING(x)+#x
#define+MAKE_STRING(x)+REALLY_MAKE_STRING(x)
#define+MACRO1(r,+data,+elem)+elem,
#define+MACRO1_STRING(r,+data,+elem)++++case+elem:+return+REALLY_MAKE_STRING(elem);
#define+MACRO1_ENUM(r,+data,+elem)++++++if+(REALLY_MAKE_STRING(elem)+==+eStrEl)+return+elem;


#define+MakeEnum(eName,+SEQ)+\
++++enum+eName+{+BOOST_PP_SEQ_FOR_EACH(MACRO1,+,+SEQ)+\
++++last_##eName##_enum};+\
++++const+int+eName##Count+=+BOOST_PP_SEQ_SIZE(SEQ);+\
++++static+std::string+eName##2String(const+enum+eName+eel)+\
++++{+\
++++++++switch+(eel)+\
++++++++{+\
++++++++BOOST_PP_SEQ_FOR_EACH(MACRO1_STRING,+,+SEQ)+\
++++++++default:+return+"Unknown+enumerator+value.";+\
++++++++};+\
++++};+\
++++static+enum+eName+eName##2Enum(const+std::string+eStrEl)+\
++++{+\
++++++++BOOST_PP_SEQ_FOR_EACH(MACRO1_ENUM,+,+SEQ)+\
++++++++return+(enum+eName)0;+\
++++};|1737757|有一些限制，也就是boost::preprocessor的限制。在这种情况下，常量列表不能大于64个元素。|1737758|遵循相同的逻辑，您还可以考虑创建稀疏枚举：|1737759|#define+EnumName(Tuple)+++++++++++++++++BOOST_PP_TUPLE_ELEM(2,+0,+Tuple)
#define+EnumValue(Tuple)++++++++++++++++BOOST_PP_TUPLE_ELEM(2,+1,+Tuple)
#define+MACRO2(r,+data,+elem)+++++++++++EnumName(elem)+EnumValue(elem),
#define+MACRO2_STRING(r,+data,+elem)++++case+EnumName(elem):+return+BOOST_PP_STRINGIZE(EnumName(elem));

#define+MakeEnumEx(eName,+SEQ)+\
++++enum+eName+{+\
++++BOOST_PP_SEQ_FOR_EACH(MACRO2,+_,+SEQ)+\
++++last_##eName##_enum+};+\
++++const+int+eName##Count+=+BOOST_PP_SEQ_SIZE(SEQ);+\
++++static+std::string+eName##2String(const+enum+eName+eel)+\
++++{+\
++++++++switch+(eel)+\
++++++++{+\
++++++++BOOST_PP_SEQ_FOR_EACH(MACRO2_STRING,+_,+SEQ)+\
++++++++default:+return+"Unknown+enumerator+value.";+\
++++++++};+\
++++};++|1737760|在这种情况下，语法为：|1737761|MakeEnumEx(TestEnum,
+++++++++++((x,))
+++++++++++((y,=1000))
+++++++++++((z,))
+++++++++++);|1737762|用法与上面类似(去掉eName##2Enum函数，您可以尝试从前面的语法推断出来)。|1737763|我在mac和linux上测试了它，但要知道boost::preprocessor可能不是完全可移植的。|1737764|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_48_0/libs/preprocessor/doc/index.html^0|2|J|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|D|3|E|5|6|7|1W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1X|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|1Z|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|20|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|21|8|@]|9|@]|C|$]]|$1|S|3|T|5|H|7|22|8|@]|9|@]|C|$I|J]]|$1|U|3|V|5|6|7|23|8|@]|9|@]|C|$]]|$1|W|3|X|5|H|7|24|8|@]|9|@]|C|$I|J]]|$1|Y|3|Z|5|6|7|25|8|@]|9|@]|C|$]]|$1|10|3|11|5|H|7|26|8|@]|9|@]|C|$I|J]]|$1|12|3|13|5|6|7|27|8|@]|9|@]|C|$]]|$1|14|3|15|5|H|7|28|8|@]|9|@]|C|$I|J]]|$1|16|3|17|5|6|7|29|8|@]|9|@]|C|$]]|$1|18|3|19|5|6|7|2A|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|H|7|2B|8|@]|9|@]|C|$I|J]]|$1|1C|3|1D|5|6|7|2C|8|@]|9|@]|C|$]]|$1|1E|3|1F|5|H|7|2D|8|@]|9|@]|C|$I|J]]|$1|1G|3|1H|5|6|7|2E|8|@]|9|@]|C|$]]|$1|1I|3|1J|5|6|7|2F|8|@]|9|@]|C|$]]|$1|1K|3|-4|5|6|7|2G|8|@]|9|@]|C|$]]]|1L|$1M|$5|1N|1O|1P|C|$1Q|1R]]]]

The use of <a href="http://www.boost.org/doc/libs/1_48_0/libs/preprocessor/doc/index.html" rel="nofollow">boost::preprocessor</a> makes possible an elegant solution like the following:

Step 1: include the header file:

<pre><code>#include "EnumUtilities.h"
</code></pre>

Step 2: declare the enumeration object with the following syntax:

<pre><code>MakeEnum( TestData,
 (x)
 (y)
 (z)
 );
</code></pre>

Step 3: use your data:

Getting the number of elements:

<pre><code>td::cout &lt;&lt; "Number of Elements: " &lt;&lt; TestDataCount &lt;&lt; std::endl;
</code></pre>

Getting the associated string:

<pre><code>std::cout &lt;&lt; "Value of " &lt;&lt; TestData2String(x) &lt;&lt; " is " &lt;&lt; x &lt;&lt; std::endl;
std::cout &lt;&lt; "Value of " &lt;&lt; TestData2String(y) &lt;&lt; " is " &lt;&lt; y &lt;&lt; std::endl;
std::cout &lt;&lt; "Value of " &lt;&lt; TestData2String(z) &lt;&lt; " is " &lt;&lt; z &lt;&lt; std::endl;
</code></pre>

Getting the enum value from the associated string:

<pre><code>std::cout &lt;&lt; "Value of x is " &lt;&lt; TestData2Enum("x") &lt;&lt; std::endl;
std::cout &lt;&lt; "Value of y is " &lt;&lt; TestData2Enum("y") &lt;&lt; std::endl;
std::cout &lt;&lt; "Value of z is " &lt;&lt; TestData2Enum("z") &lt;&lt; std::endl;
</code></pre>

This looks clean and compact, with no extra files to include.
The code I wrote within EnumUtilities.h is the following:

<pre><code>#include &lt;boost/preprocessor/seq/for_each.hpp&gt;
#include &lt;string&gt;

#define REALLY_MAKE_STRING(x) #x
#define MAKE_STRING(x) REALLY_MAKE_STRING(x)
#define MACRO1(r, data, elem) elem,
#define MACRO1_STRING(r, data, elem) case elem: return REALLY_MAKE_STRING(elem);
#define MACRO1_ENUM(r, data, elem) if (REALLY_MAKE_STRING(elem) == eStrEl) return elem;


#define MakeEnum(eName, SEQ) \
 enum eName { BOOST_PP_SEQ_FOR_EACH(MACRO1, , SEQ) \
 last_##eName##_enum}; \
 const int eName##Count = BOOST_PP_SEQ_SIZE(SEQ); \
 static std::string eName##2String(const enum eName eel) \
 { \
 switch (eel) \
 { \
 BOOST_PP_SEQ_FOR_EACH(MACRO1_STRING, , SEQ) \
 default: return "Unknown enumerator value."; \
 }; \
 }; \
 static enum eName eName##2Enum(const std::string eStrEl) \
 { \
 BOOST_PP_SEQ_FOR_EACH(MACRO1_ENUM, , SEQ) \
 return (enum eName)0; \
 };
</code></pre>

There are some limitation, i.e. the ones of boost::preprocessor. In this case, the list of constants cannot be larger than 64 elements.

Following the same logic, you could also think to create sparse enum:

<pre><code>#define EnumName(Tuple) BOOST_PP_TUPLE_ELEM(2, 0, Tuple)
#define EnumValue(Tuple) BOOST_PP_TUPLE_ELEM(2, 1, Tuple)
#define MACRO2(r, data, elem) EnumName(elem) EnumValue(elem),
#define MACRO2_STRING(r, data, elem) case EnumName(elem): return BOOST_PP_STRINGIZE(EnumName(elem));

#define MakeEnumEx(eName, SEQ) \
 enum eName { \
 BOOST_PP_SEQ_FOR_EACH(MACRO2, _, SEQ) \
 last_##eName##_enum }; \
 const int eName##Count = BOOST_PP_SEQ_SIZE(SEQ); \
 static std::string eName##2String(const enum eName eel) \
 { \
 switch (eel) \
 { \
 BOOST_PP_SEQ_FOR_EACH(MACRO2_STRING, _, SEQ) \
 default: return "Unknown enumerator value."; \
 }; \
 }; 
</code></pre>

In this case, the syntax is:

<pre><code>MakeEnumEx(TestEnum,
 ((x,))
 ((y,=1000))
 ((z,))
 );
</code></pre>

Usage is similar as above (minus the eName##2Enum function, that you could try to extrapolate from the previous syntax).

I tested it on mac and linux, but be aware that boost::preprocessor may not be fully portable.

blocks|key|1522755|text|#define+stringify(+name+)+#+name

enum+MyEnum+{
++++ENUMVAL1
};
...stuff...

stringify(EnumName::ENUMVAL1);++//+Returns+MyEnum::ENUMVAL1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1522756|Further+discussion+on+this+method|unstyled|offset|length|1522757|Preprocessor+directive+tricks+for+newcomers|1522758|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/forum/general/2949/|1|http://www.cprogramming.com/tutorial/cpreprocessor.html^0|0|0|X|0|0|0|17|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@$G|W|H|X|1|Y]]|A|$]]|$1|I|3|J|5|F|7|Z|8|@]|9|@$G|10|H|11|1|12]]|A|$]]|$1|K|3|-4|5|F|7|13|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

<pre><code>#define stringify( name ) # name

enum MyEnum {
 ENUMVAL1
};
...stuff...

stringify(EnumName::ENUMVAL1); // Returns MyEnum::ENUMVAL1
</code></pre>

<a href="http://www.cplusplus.com/forum/general/2949/" rel="nofollow">Further discussion on this method</a> 

<a href="http://www.cprogramming.com/tutorial/cpreprocessor.html" rel="nofollow">Preprocessor directive tricks for newcomers</a>

blocks|key|1522811|text|我已经创建了一个简单的模板化类streamable_enum，它使用流运算符<<和>>，并基于std::map<Enum,+std::string>：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1522812|#ifndef+STREAMABLE_ENUM_HPP
#define+STREAMABLE_ENUM_HPP

#include+<iostream>
#include+<string>
#include+<map>

template+<typename+E>
class+streamable_enum
{
public:
++++typedef+typename+std::map<E,+std::string>+tostr_map_t;
++++typedef+typename+std::map<std::string,+E>+fromstr_map_t;

++++streamable_enum()
++++{}

++++streamable_enum(E+val)+:
++++++++Val_(val)
++++{}

++++operator+E()+{
++++++++return+Val_;
++++}

++++bool+operator==(const+streamable_enum<E>&+e)+{
++++++++return+this->Val_+==+e.Val_;
++++}

++++bool+operator==(const+E&+e)+{
++++++++return+this->Val_+==+e;
++++}

++++static+const+tostr_map_t&+to_string_map()+{
++++++++static+tostr_map_t+to_str_(get_enum_strings<E>());
++++++++return+to_str_;
++++}

++++static+const+fromstr_map_t&+from_string_map()+{
++++++++static+fromstr_map_t+from_str_(reverse_map(to_string_map()));
++++++++return+from_str_;
++++}
private:
++++E+Val_;

++++static+fromstr_map_t+reverse_map(const+tostr_map_t&+eToS)+{
++++++++fromstr_map_t+sToE;
++++++++for+(auto+pr+:+eToS)+{
++++++++++++sToE.emplace(pr.second,+pr.first);
++++++++}
++++++++return+sToE;
++++}
};

template+<typename+E>
streamable_enum<E>+stream_enum(E+e)+{
++++return+streamable_enum<E>(e);
}

template+<typename+E>
typename+streamable_enum<E>::tostr_map_t+get_enum_strings()+{
++++//+\todo+throw+an+appropriate+exception+or+display+compile+error/warning
++++return+{};
}

template+<typename+E>
std::ostream&+operator<<(std::ostream&+os,+streamable_enum<E>+e)+{
++++auto&+mp+=+streamable_enum<E>::to_string_map();
++++auto+res+=+mp.find(e);
++++if+(res+!=+mp.end())+{
++++++++os+<<+res->second;
++++}+else+{
++++++++os.setstate(std::ios_base::failbit);
++++}
++++return+os;
}

template+<typename+E>
std::istream&+operator>>(std::istream&+is,+streamable_enum<E>&+e)+{
++++std::string+str;
++++is+>>+str;
++++if+(str.empty())+{
++++++++is.setstate(std::ios_base::failbit);
++++}
++++auto&+mp+=+streamable_enum<E>::from_string_map();
++++auto+res+=+mp.find(str);
++++if+(res+!=+mp.end())+{
++++++++e+=+res->second;
++++}+else+{
++++++++is.setstate(std::ios_base::failbit);
++++}
++++return+is;
}

#endif|code-block|syntax|javascript|1522813|用法：|1522814|#include+"streamable_enum.hpp"

using+std::cout;
using+std::cin;
using+std::endl;

enum+Animal+{
++++CAT,
++++DOG,
++++TIGER,
++++RABBIT
};

template+<>
streamable_enum<Animal>::tostr_map_t+get_enum_strings<Animal>()+{
++++return+{
++++++++{+CAT,+"Cat"},
++++++++{+DOG,+"Dog"+},
++++++++{+TIGER,+"Tiger"+},
++++++++{+RABBIT,+"Rabbit"+}
++++};
}

int+main(int+argc,+char*+argv+[])+{
++++cout+<<+"What+animal+do+you+want+to+buy?+Our+offering:"+<<+endl;
++++for+(auto+pr+:+streamable_enum<Animal>::to_string_map())+{++++++++++//+Use+from_string_map()+and+pr.first+instead
++++++++cout+<<+"+"+<<+pr.second+<<+endl;+++++++++++++++++++++++++++++++//+to+have+them+sorted+in+alphabetical+order
++++}
++++streamable_enum<Animal>+anim;
++++cin+>>+anim;
++++if+(!cin)+{
++++++++cout+<<+"We+don't+have+such+animal+here."+<<+endl;
++++}+else+if+(anim+==+Animal::TIGER)+{
++++++++cout+<<+stream_enum(Animal::TIGER)+<<+"+was+a+joke..."+<<+endl;
++++}+else+{
++++++++cout+<<+"Here+you+are!"+<<+endl;
++++}

++++return+0;
}|1522815|entityMap^0|F|F|12|2|15|2|1B|R|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

I have created a simple templated class <code>streamable_enum</code> that uses stream operators <code>&lt;&lt;</code> and <code>&gt;&gt;</code> and is based on the <code>std::map&lt;Enum, std::string&gt;</code>: 

<pre><code>#ifndef STREAMABLE_ENUM_HPP
#define STREAMABLE_ENUM_HPP

#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;map&gt;

template &lt;typename E&gt;
class streamable_enum
{
public:
 typedef typename std::map&lt;E, std::string&gt; tostr_map_t;
 typedef typename std::map&lt;std::string, E&gt; fromstr_map_t;

 streamable_enum()
 {}

 streamable_enum(E val) :
 Val_(val)
 {}

 operator E() {
 return Val_;
 }

 bool operator==(const streamable_enum&lt;E&gt;&amp; e) {
 return this-&gt;Val_ == e.Val_;
 }

 bool operator==(const E&amp; e) {
 return this-&gt;Val_ == e;
 }

 static const tostr_map_t&amp; to_string_map() {
 static tostr_map_t to_str_(get_enum_strings&lt;E&gt;());
 return to_str_;
 }

 static const fromstr_map_t&amp; from_string_map() {
 static fromstr_map_t from_str_(reverse_map(to_string_map()));
 return from_str_;
 }
private:
 E Val_;

 static fromstr_map_t reverse_map(const tostr_map_t&amp; eToS) {
 fromstr_map_t sToE;
 for (auto pr : eToS) {
 sToE.emplace(pr.second, pr.first);
 }
 return sToE;
 }
};

template &lt;typename E&gt;
streamable_enum&lt;E&gt; stream_enum(E e) {
 return streamable_enum&lt;E&gt;(e);
}

template &lt;typename E&gt;
typename streamable_enum&lt;E&gt;::tostr_map_t get_enum_strings() {
 // \todo throw an appropriate exception or display compile error/warning
 return {};
}

template &lt;typename E&gt;
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, streamable_enum&lt;E&gt; e) {
 auto&amp; mp = streamable_enum&lt;E&gt;::to_string_map();
 auto res = mp.find(e);
 if (res != mp.end()) {
 os &lt;&lt; res-&gt;second;
 } else {
 os.setstate(std::ios_base::failbit);
 }
 return os;
}

template &lt;typename E&gt;
std::istream&amp; operator&gt;&gt;(std::istream&amp; is, streamable_enum&lt;E&gt;&amp; e) {
 std::string str;
 is &gt;&gt; str;
 if (str.empty()) {
 is.setstate(std::ios_base::failbit);
 }
 auto&amp; mp = streamable_enum&lt;E&gt;::from_string_map();
 auto res = mp.find(str);
 if (res != mp.end()) {
 e = res-&gt;second;
 } else {
 is.setstate(std::ios_base::failbit);
 }
 return is;
}

#endif
</code></pre>

Usage:

<pre><code>#include "streamable_enum.hpp"

using std::cout;
using std::cin;
using std::endl;

enum Animal {
 CAT,
 DOG,
 TIGER,
 RABBIT
};

template &lt;&gt;
streamable_enum&lt;Animal&gt;::tostr_map_t get_enum_strings&lt;Animal&gt;() {
 return {
 { CAT, "Cat"},
 { DOG, "Dog" },
 { TIGER, "Tiger" },
 { RABBIT, "Rabbit" }
 };
}

int main(int argc, char* argv []) {
 cout &lt;&lt; "What animal do you want to buy? Our offering:" &lt;&lt; endl;
 for (auto pr : streamable_enum&lt;Animal&gt;::to_string_map()) { // Use from_string_map() and pr.first instead
 cout &lt;&lt; " " &lt;&lt; pr.second &lt;&lt; endl; // to have them sorted in alphabetical order
 }
 streamable_enum&lt;Animal&gt; anim;
 cin &gt;&gt; anim;
 if (!cin) {
 cout &lt;&lt; "We don't have such animal here." &lt;&lt; endl;
 } else if (anim == Animal::TIGER) {
 cout &lt;&lt; stream_enum(Animal::TIGER) &lt;&lt; " was a joke..." &lt;&lt; endl;
 } else {
 cout &lt;&lt; "Here you are!" &lt;&lt; endl;
 }

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

blocks|key|1737868|text|如果您使用的是gcc，则可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737869|const+char+*+enum_to_string_map[]={+[enum1]='string1',+[enum2]='string2'};|code-block|syntax|javascript|1737870|然后调用例如|1737871|enum_to_string_map[enum1]|1737872|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|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you are using gcc, it's possible to use:

<pre><code>const char * enum_to_string_map[]={ [enum1]='string1', [enum2]='string2'};
</code></pre>

Then just call for instance

<pre><code>enum_to_string_map[enum1]
</code></pre>

blocks|key|1522896|text|通过合并这里的一些技术，我得到了最简单的形式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522897|#define+MACROSTR(k)+#k

#define+X_NUMBERS+\
+++++++X(kZero++)+\
+++++++X(kOne+++)+\
+++++++X(kTwo+++)+\
+++++++X(kThree+)+\
+++++++X(kFour++)+\
+++++++X(kMax+++)

enum+{
#define+X(Enum)+++++++Enum,
++++X_NUMBERS
#undef+X
}+kConst;

static+char+*kConstStr[]+=+{
#define+X(String)+MACROSTR(String),
++++X_NUMBERS
#undef+X
};

int+main(void)
{
++++int+k;
++++printf("Hello+World!\n\n");

++++for+(k+=+0;+k+<+kMax;+k%2B%2B)
++++{
++++++++printf("%25s\n",+kConstStr[k]);
++++}

++++return+0;
}|code-block|syntax|javascript|1522898|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|$]]

By merging some of the techniques over here I came up with the simplest form:

<pre><code>#define MACROSTR(k) #k

#define X_NUMBERS \
 X(kZero ) \
 X(kOne ) \
 X(kTwo ) \
 X(kThree ) \
 X(kFour ) \
 X(kMax )

enum {
#define X(Enum) Enum,
 X_NUMBERS
#undef X
} kConst;

static char *kConstStr[] = {
#define X(String) MACROSTR(String),
 X_NUMBERS
#undef X
};

int main(void)
{
 int k;
 printf("Hello World!\n\n");

 for (k = 0; k &lt; kMax; k++)
 {
 printf("%s\n", kConstStr[k]);
 }

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

blocks|key|1522946|text|因为出于所有常见的原因，我不喜欢使用宏，所以我使用了一种更有限的宏解决方案，它的优点是使枚举声明宏保持自由。缺点包括必须为每个枚举复制粘贴宏定义，以及在向枚举添加值时必须显式添加宏调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522947|std::ostream&+operator<<(std::ostream&+os,+provenance_wrapper::CaptureState+cs)
{
#define+HANDLE(x)+case+x:+os+<<+#x;+break;
++++switch+(cs)+{
++++HANDLE(CaptureState::UNUSED)
++++HANDLE(CaptureState::ACTIVE)
++++HANDLE(CaptureState::CLOSED)
++++}
++++return+os;
#undef+HANDLE
}|code-block|syntax|javascript|1522948|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|$]]

Because I prefer not to use macros for all the usual reasons, I used a more limited macro solution that has the advantage of keeping the enum declaration macro free. Disadvantages include having to copy paste the macro defintion for each enum, and having to explicitly add a macro invocation when adding values to the enum.

<pre><code>std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, provenance_wrapper::CaptureState cs)
{
#define HANDLE(x) case x: os &lt;&lt; #x; break;
 switch (cs) {
 HANDLE(CaptureState::UNUSED)
 HANDLE(CaptureState::ACTIVE)
 HANDLE(CaptureState::CLOSED)
 }
 return os;
#undef HANDLE
}
</code></pre>

blocks|key|1522995|text|有一种更简单和更清晰的方法在这个帖子上是没有的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522996|++++#define+ENUM_PUSH(ENUM)+++ENUM,
++++#define+STRING_PUSH(STR)++#STR,
++++
++++#define+FETCH_MSG(X)++++++\
++++++++++++X(string1)++++++++\
++++++++++++X(string2)++++++++\
++++
++++static+const+char+*+msgStr[]+=+{
++++++++FETCH_MSG(STRING_PUSH)
++++};
++++
++++enum+msg+{
++++++++FETCH_MSG(ENUM_PUSH)
++++};
++++
++++static+enum+msg+message;
++++
++++
++++void+iterate(void)+{
++++++++switch+(message)+{
++++++++case+string1:
//+do+your+thing+here
++++++++++++break;
++++++++case+string2:
++++++++++++break;
++++++++}
++++}|code-block|syntax|javascript|1522997|唯一的缺点是最后一个单元格将后缀一个逗号，尽管它似乎可以被C/C%2B%2B编译器接受。|1522998|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

There's a way simpler and imo sorta clearer approach
that was missing on this thread:
<pre><code> #define ENUM_PUSH(ENUM) ENUM,
 #define STRING_PUSH(STR) #STR,
 
 #define FETCH_MSG(X) \
 X(string1) \
 X(string2) \
 
 static const char * msgStr[] = {
 FETCH_MSG(STRING_PUSH)
 };
 
 enum msg {
 FETCH_MSG(ENUM_PUSH)
 };
 
 static enum msg message;
 
 
 void iterate(void) {
 switch (message) {
 case string1:
// do your thing here
 break;
 case string2:
 break;
 }
 }
</code></pre>
The only downside is that the last cell will be postceded by a comma,
though it appears to be acceptable by C/C++ compilers.

Here's what I am trying to do: 

<pre><code>typedef enum { ONE, TWO, THREE } Numbers;
</code></pre>

I am trying to write a function that would do a switch case similar to the following: 

<pre><code>char num_str[10];
int process_numbers_str(Numbers num) {
 switch(num) {
 case ONE:
 case TWO:
 case THREE:
 {
 strcpy(num_str, num); //some way to get the symbolic constant name in here?
 } break;
 default:
 return 0; //no match
 return 1;
}
</code></pre>

Instead of defining at every case, is there a way to set it using the enum variable like I am trying to do above?

Easy way to use variables of enum types as string in C?

编译器

这是我想要做的：typedef enum { ONE, TWO, THREE } Numbers;我正在尝试编写一个函数，它将执行类似于以下内容的切换情况：char num_str[10];int process_numbers_str(Numbers num) {  switch(num) {    case ONE...

问在C中使用枚举类型的变量作为字符串的简单方法？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中使用枚举类型的变量作为字符串的简单方法？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中使用枚举类型的变量作为字符串的简单方法？
EN