如何在C中将枚举名称转换为字符串

92

是否可以在C中将枚举器名称转换为字符串？

c  string  enums 
— 米莎
source

Answers:

185

一种方法，使预处理器完成工作。它还可以确保您的枚举和字符串同步。

#define FOREACH_FRUIT(FRUIT) \
        FRUIT(apple)   \
        FRUIT(orange)  \
        FRUIT(grape)   \
        FRUIT(banana)  \

#define GENERATE_ENUM(ENUM) ENUM,
#define GENERATE_STRING(STRING) #STRING,

enum FRUIT_ENUM {
    FOREACH_FRUIT(GENERATE_ENUM)
};

static const char *FRUIT_STRING[] = {
    FOREACH_FRUIT(GENERATE_STRING)
};

预处理器完成后，您将具有：

enum FRUIT_ENUM {
    apple, orange, grape, banana,
};

static const char *FRUIT_STRING[] = {
    "apple", "orange", "grape", "banana",
};

然后，您可以执行以下操作：

printf("enum apple as a string: %s\n",FRUIT_STRING[apple]);

如果用例实际上只是打印枚举名称，请添加以下宏：

#define str(x) #x
#define xstr(x) str(x)

然后做：

printf("enum apple as a string: %s\n", xstr(apple));

在这种情况下，似乎两级宏是多余的，但是，由于字符串在C中的工作方式，在某些情况下是必需的。例如，假设我们要对枚举使用#define：

#define foo apple

int main() {
    printf("%s\n", str(foo));
    printf("%s\n", xstr(foo));
}

输出为：

foo
apple

这是因为str会将输入的foo字符串化，而不是将其扩展为apple。通过使用xstr，首先完成宏扩展，然后将结果字符串化。

有关更多信息，请参见字符串化。

— 特伦斯·M
source
1
这是完美的，但我无法理解实际情况。：O
— p0lAris
在上述情况下，又如何将字符串转换为枚举？
— p0lAris
有几种方法可以完成，具体取决于您要实现的目标？
— Terrence M
5
如果您不想用苹果和橙子污染名称空间，则可以添加前缀#define GENERATE_ENUM(ENUM) PREFIX##ENUM,
— jsaak
1
对于那些接触过这篇文章的人，这种使用宏列表枚举程序中各种项目的方法被非正式地称为“ X宏”。
— 隆丁'18
27

在这种情况下：

enum fruit {
    apple, 
    orange, 
    grape,
    banana,
    // etc.
};

我喜欢将其放在定义枚举的头文件中：

static inline char *stringFromFruit(enum fruit f)
{
    static const char *strings[] = { "apple", "orange", "grape", "banana", /* continue for rest of values */ };

    return strings[f];
}
— 理查德·罗斯三世
source
4
对于我的一生，我看不到这有什么帮助。您可以扩大一点使其更明显吗？
— David Heffernan
2
好的，那有什么帮助？您是说打字enumToString(apple)比打字容易"apple"吗？并不是任何地方都存在类型安全性。除非我遗漏了某些东西，否则您在这里提出的建议是毫无意义的，只会成功混淆代码。
— David Heffernan
2
好，我现在知道了。我认为该宏是虚假的，建议您删除它。
— David Heffernan
2
评论谈论宏。它在哪里？
— mk..14-4-04
2
这也给维护带来不便。如果我插入一个新的枚举，我必须记住要在数组中的正确位置复制该枚举。
— 法比奥
14

没有简单的方法可以直接实现这一目标。但是P99具有允许您自动创建此类功能的宏：

 P99_DECLARE_ENUM(color, red, green, blue);

在头文件中，以及

 P99_DEFINE_ENUM(color);

然后在一个编译单元（.c文件）中执行此操作，在该示例中，该函数将被调用color_getname。

— 延斯·古斯特
source
我如何拉这个库？
— JohnyTex
14

我发现一个C预处理程序技巧可以完成相同的工作，而无需声明专用的数组字符串（来源：http : //userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/c_preprocessor_applications_en）。

顺序枚举

继Stefan Ram的发明之后，enum {foo=-1, foo1 = 1}可以像这样的天才技巧一样实现顺序枚举（无需明确说明索引，例如）：

#include <stdio.h>

#define NAMES C(RED)C(GREEN)C(BLUE)
#define C(x) x,
enum color { NAMES TOP };
#undef C

#define C(x) #x,    
const char * const color_name[] = { NAMES };

得到以下结果：

int main( void )  { 
    printf( "The color is %s.\n", color_name[ RED ]);  
    printf( "There are %d colors.\n", TOP ); 
}

颜色是红色。
有3种颜色。

非顺序枚举

由于我想将错误代码定义映射为数组字符串，以便可以将原始错误定义附加到错误代码（例如"The error is 3 (LC_FT_DEVICE_NOT_OPENED)."），因此我以这种方式扩展了代码，从而可以轻松地确定各个枚举值所需的索引：

#define LOOPN(n,a) LOOP##n(a)
#define LOOPF ,
#define LOOP2(a) a LOOPF a LOOPF
#define LOOP3(a) a LOOPF a LOOPF a LOOPF
#define LOOP4(a) a LOOPF a LOOPF a LOOPF a LOOPF
#define LOOP5(a) a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF
#define LOOP6(a) a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF
#define LOOP7(a) a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF
#define LOOP8(a) a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF
#define LOOP9(a) a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF a LOOPF


#define LC_ERRORS_NAMES \
    Cn(LC_RESPONSE_PLUGIN_OK, -10) \
    Cw(8) \
    Cn(LC_RESPONSE_GENERIC_ERROR, -1) \
    Cn(LC_FT_OK, 0) \
    Ci(LC_FT_INVALID_HANDLE) \
    Ci(LC_FT_DEVICE_NOT_FOUND) \
    Ci(LC_FT_DEVICE_NOT_OPENED) \
    Ci(LC_FT_IO_ERROR) \
    Ci(LC_FT_INSUFFICIENT_RESOURCES) \
    Ci(LC_FT_INVALID_PARAMETER) \
    Ci(LC_FT_INVALID_BAUD_RATE) \
    Ci(LC_FT_DEVICE_NOT_OPENED_FOR_ERASE) \
    Ci(LC_FT_DEVICE_NOT_OPENED_FOR_WRITE) \
    Ci(LC_FT_FAILED_TO_WRITE_DEVICE) \
    Ci(LC_FT_EEPROM_READ_FAILED) \
    Ci(LC_FT_EEPROM_WRITE_FAILED) \
    Ci(LC_FT_EEPROM_ERASE_FAILED) \
    Ci(LC_FT_EEPROM_NOT_PRESENT) \
    Ci(LC_FT_EEPROM_NOT_PROGRAMMED) \
    Ci(LC_FT_INVALID_ARGS) \
    Ci(LC_FT_NOT_SUPPORTED) \
    Ci(LC_FT_OTHER_ERROR) \
    Ci(LC_FT_DEVICE_LIST_NOT_READY)


#define Cn(x,y) x=y,
#define Ci(x) x,
#define Cw(x)
enum LC_errors { LC_ERRORS_NAMES TOP };
#undef Cn
#undef Ci
#undef Cw
#define Cn(x,y) #x,
#define Ci(x) #x,
#define Cw(x) LOOPN(x,"")
static const char* __LC_errors__strings[] = { LC_ERRORS_NAMES };
static const char** LC_errors__strings = &__LC_errors__strings[10];

在此示例中，C预处理器将生成以下代码：

enum LC_errors { LC_RESPONSE_PLUGIN_OK=-10,  LC_RESPONSE_GENERIC_ERROR=-1, LC_FT_OK=0, LC_FT_INVALID_HANDLE, LC_FT_DEVICE_NOT_FOUND, LC_FT_DEVICE_NOT_OPENED, LC_FT_IO_ERROR, LC_FT_INSUFFICIENT_RESOURCES, LC_FT_INVALID_PARAMETER, LC_FT_INVALID_BAUD_RATE, LC_FT_DEVICE_NOT_OPENED_FOR_ERASE, LC_FT_DEVICE_NOT_OPENED_FOR_WRITE, LC_FT_FAILED_TO_WRITE_DEVICE, LC_FT_EEPROM_READ_FAILED, LC_FT_EEPROM_WRITE_FAILED, LC_FT_EEPROM_ERASE_FAILED, LC_FT_EEPROM_NOT_PRESENT, LC_FT_EEPROM_NOT_PROGRAMMED, LC_FT_INVALID_ARGS, LC_FT_NOT_SUPPORTED, LC_FT_OTHER_ERROR, LC_FT_DEVICE_LIST_NOT_READY, TOP };

static const char* __LC_errors__strings[] = { "LC_RESPONSE_PLUGIN_OK", "" , "" , "" , "" , "" , "" , "" , "" "LC_RESPONSE_GENERIC_ERROR", "LC_FT_OK", "LC_FT_INVALID_HANDLE", "LC_FT_DEVICE_NOT_FOUND", "LC_FT_DEVICE_NOT_OPENED", "LC_FT_IO_ERROR", "LC_FT_INSUFFICIENT_RESOURCES", "LC_FT_INVALID_PARAMETER", "LC_FT_INVALID_BAUD_RATE", "LC_FT_DEVICE_NOT_OPENED_FOR_ERASE", "LC_FT_DEVICE_NOT_OPENED_FOR_WRITE", "LC_FT_FAILED_TO_WRITE_DEVICE", "LC_FT_EEPROM_READ_FAILED", "LC_FT_EEPROM_WRITE_FAILED", "LC_FT_EEPROM_ERASE_FAILED", "LC_FT_EEPROM_NOT_PRESENT", "LC_FT_EEPROM_NOT_PROGRAMMED", "LC_FT_INVALID_ARGS", "LC_FT_NOT_SUPPORTED", "LC_FT_OTHER_ERROR", "LC_FT_DEVICE_LIST_NOT_READY", };

这导致以下实现功能：

LC_errors__strings [-1] ==> LC_errors__strings [LC_RESPONSE_GENERIC_ERROR] ==>“ LC_RESPONSE_GENERIC_ERROR”

— Maschina
source
真好 这正是我一直在寻找和使用它的方式。同样的错误:)
— mrbean
5

您无需依赖预处理程序来确保您的枚举和字符串是同步的。对我来说，使用宏会使代码更难阅读。

使用枚举和字符串数组

enum fruit                                                                   
{
    APPLE = 0, 
    ORANGE, 
    GRAPE,
    BANANA,
    /* etc. */
    FRUIT_MAX                                                                                                                
};   

const char * const fruit_str[] =
{
    [BANANA] = "banana",
    [ORANGE] = "orange",
    [GRAPE]  = "grape",
    [APPLE]  = "apple",
    /* etc. */  
};

注意：fruit_str数组中的字符串不必以与枚举项相同的顺序声明。

如何使用它

printf("enum apple as a string: %s\n", fruit_str[APPLE]);

添加编译时间检查

如果您害怕忘记一个字符串，可以添加以下检查：

#define ASSERT_ENUM_TO_STR(sarray, max) \                                       
  typedef char assert_sizeof_##max[(sizeof(sarray)/sizeof(sarray[0]) == (max)) ? 1 : -1]

ASSERT_ENUM_TO_STR(fruit_str, FRUIT_MAX);

如果枚举项的数量与数组中字符串的数量不匹配，则会在编译时报告错误。

— y
source
2

诸如此类的函数如果没有验证枚举，将是一件小事。我建议使用switch语句。另一个优点是，它可以用于具有定义值的枚举，例如值分别为1,2,4,8,16的标志等。

还将所有枚举字符串放在一个数组中：

static const char * allEnums[] = {
    "Undefined",
    "apple",
    "orange"
    /* etc */
};

在头文件中定义索引：

#define ID_undefined       0
#define ID_fruit_apple     1
#define ID_fruit_orange    2
/* etc */

这样做可以更轻松地产生不同的版本，例如，如果您想使用其他语言制作程序的国际版本。

在头文件中也使用宏：-

#define CASE(type,val) case val: index = ID_##type##_##val; break;

使用switch语句创建函数，这应该返回a，const char *因为字符串静态consts：-

const char * FruitString(enum fruit e){

    unsigned int index;

    switch(e){
        CASE(fruit, apple)
        CASE(fruit, orange)
        CASE(fruit, banana)
        /* etc */
        default: index = ID_undefined;
    }
    return allEnums[index];
}

如果使用Windows编程，则ID_值可以是资源值。

（如果使用C ++，则所有函数可以具有相同的名称。

string EnumToString(fruit e);

）

— 昆汀英国
source
2

基于使用指示符实例化字符串数组的一种更简单的Hokyo“非顺序枚举”答案的替代方案：

#define NAMES C(RED, 10)C(GREEN, 20)C(BLUE, 30)
#define C(k, v) k = v,
enum color { NAMES };
#undef C

#define C(k, v) [v] = #k,    
const char * const color_name[] = { NAMES };
— 拉尔斯
source
-2

我通常这样做：

#define COLOR_STR(color)                            \
    (RED       == color ? "red"    :                \
     (BLUE     == color ? "blue"   :                \
      (GREEN   == color ? "green"  :                \
       (YELLOW == color ? "yellow" : "unknown"))))
— 吉利比巴拉
source
1
这简直是​​荒谬的
— Massimo Callegari'Mar
这不是一个坏答案。它清晰，简单且易于理解。如果您正在其他人需要快速阅读和理解您的代码的系统上工作，那么清晰度非常重要。我不建议使用预处理器技巧，除非在编码标准中对其进行了充分的注释或描述。
— nielsen
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.