访问结构的联合成员的优雅方式

Question

有没有办法反转#define指令？

在下面的例子中

#define ZERO 0
#define ONE 1
#define TWO 2
#define THREE 3

是否可以从整数值 2 中检索两个？

此示例来自 C 代码，但如果需要，我可以使用一些 C++ 代码。我的目标是能够分解这种形式的一些虚假的 switch-case 循环：

switch(num)
{
   case ZERO:
      return std::to_string(foo.V_ZERO);
   case ONE:
      return std::to_string(foo.V_ONE);
   case TWO:
      return std::to_string(foo.V_TWO);
   case THREE:
      return std::to_string(foo.V_THREE);
}

其中 foo 是这样的结构的一个实例：

struct Foo
{
   union Val
   { 
      int V_ZERO;
      int V_ONE;
      double V_TWO; // nonsense: just to say that types are not the same
      int V_THREE;
   };
};

我的限制如下：

1. 我无法删除#define 提供的功能，即我可以写一些等效的东西，例如一个枚举，但我不能丢失 ZERO 和 0、ONE 和 1 等之间的映射；
2. 现有代码是用 C 编写的，我无法用 C++ 重写它。不过，我可以编写一些补充的 C++ 代码。

我有一些简化代码的想法，但我想知道是否有一种众所周知的优雅方法可以做到这一点，尤其是通过一些模板或预处理器指令。

编辑：添加 std::to_string 的用法表示我对知道如何转换或处理联合中的多种类型不感兴趣。

Answer 1

如果您想自动化某些过程，一种选择是使用 xmacros。它们很老套，但根据您的代码大小，可能会使维护（例如添加新条目）更容易，但代价是您同事的愤怒：

定义xmacro列表：

#define XLIST(xmacro) \
   xmacro(ZERO, 0) \
   xmacro(ONE, 1) \
   xmacro(TWO, 2) \
   xmacro(THREE, 3) \

然后在您想要遍历所有项目时使用它：

// create an enum containing all items
#define xmacro(name, value) name,
enum Item
{
    XLIST(xmacro)
};
#undef xmacro

// get the number of items
#define xmacro(name, value) +1
const int NumberOfItems = 0 XLIST(xmacro);
#undef xmacro

// enum -> value
int itemToValue(enum Item item)
{
    switch (item)
    {
        // create a mapping from enum to x
#define xmacro(name, value) case name: return value;
        XLIST(xmacro)
#undef xmacro
    }

    return -1;
}

// get enum name
const char * getItemName(enum Item item)
{
    switch (item)
    {
        // create a mapping from enum to x
#define xmacro(name, value) case name: return #name;
        XLIST(xmacro)
#undef xmacro
    }

    return NULL;
}

这将被预处理为：

enum Item
{
    ZERO,
    ONE, 
    TWO, 
    THREE,
};

const int NumberOfItems = 0 +1 +1 +1 +1; // == 4

int itemToValue(enum Item item)
{
    switch (item)
    {
        case ZERO: return 0; 
        case ONE: return 1; 
        case TWO: return 2; 
        case THREE: return 3;   
    }

    return -1;
}

const char * getItemName(enum Item item)
{
    switch (item)
    {
        case ZERO: return "ZERO"; 
        case ONE: return "ONE"; 
        case TWO: return "TWO"; 
        case THREE: return "THREE";

    }

    return NULL;
}

您可以从中创建几乎任何您想要的映射，即对于您的结构，您可以使用类似于 @Jean-François 所写的内容：

// get struct value by item type
double getValueByName(enum Item item, struct Foo values)
{
    switch (item)
    {
        // create a mapping from enum to x
#define xmacro(name, value) case name: return values.V_##name;
        XLIST(xmacro)
#undef xmacro
    }

    return -1;
}

Answer 2

不，这是不可能的。

预处理器#defines 被预处理阶段的文本替换为它们的定义。实际的编译器永远不会看到这些符号。你觉得TWO 是，在运行时是什么？它已经被整数文字 2 替换，所以没有任何变化。

const int two_define = TWO;
const int two_literal = 2;

都会将整数值2 放入各自的变量中，没有什么神奇的气味可以以某种方式将TWO 与2 区分开来。编译器将看到const int two_define = 2;，因为预处理器符号将消失。

另外：假设您同时返回ints 和doubles，函数的实际返回类型是什么？这意味着它是double。

Answer 3

在一般情况下，您必须求助于“X 宏”之类的东西，正如另一个答案中所建议的那样。但这是其他一切都失败时的最后手段。如果数字完全是任意的，你就必须去那里。

但是，在这种特定情况下，数字是相邻的并且从零开始。这需要enum 与查找表相结合。实现它的标准方法是这样的：

#include <stdio.h>

typedef enum
{
  ZERO,
  ONE,
  TWO,
  THREE,
  SUPPORTED_NUMBERS
} number_t;

const char* STR_NUMBER [] =
{
  "ZERO",
  "ONE",
  "TWO",
  "THREE",
};

_Static_assert((sizeof STR_NUMBER / sizeof *STR_NUMBER) == SUPPORTED_NUMBERS,
               "Error: enum does not correspond to look-up table.");

int main (void)
{
  for(number_t i=0; i<SUPPORTED_NUMBERS; i++)
  {
    printf("%d %s\n", i, STR_NUMBER[i]);
  }
}

Answer 4

对于这两个问题：

有没有办法反转#define指令？

是否可以从整数值 2 中检索两个？

也许映射结构数组适合你：

#define ZERO 0
#define ONE 1
#define TWO 2
#define THREE 3

typedef struct
{
    int number;
    const char *name;
} name_map_t;


#define MAP_NAME_STR(id) { id, #id },


static const name_map_t name_map_table[] =
{
    MAP_NAME_STR( ZERO  )
    MAP_NAME_STR( ONE   )
    MAP_NAME_STR( TWO   )
    MAP_NAME_STR( THREE )
};

然后只需循环 name_map_table 数组即可找到想要的对应对象。

Answer 5

我发现了你的问题，当我遇到这种枚举模式时，我会告诉你我该怎么做：

假设我有一个值枚举，我想将其打印到switch，以表示数组索引等。

首先我编写了一个包含文件，它将支持我将要对这个枚举类型进行的各种使用：

enum(INITIAL_STATE, 0, "This is the initial state")
enum(FLAG_READ, 1, "We have read the flag symbol")
...

然后我使用不同的宏定义来扩展这个寄存器数据集，如下：

struct enum MyEnum {
#define enum(val,ix, string) val,
#include "myenumdef.i"
#undef enum
};

/* then, later in the same file ... */

char *MyEnumStrings[] = {
#define enum(val,ix, string) string,
#include "myenumdef.i"
#undef enum
};

/* .... */

char *MyEnumNames[] = {
#define enum(val, ix, string) #val, /* the string equivalent of enum names */
#include "myenumdef.i"
#undef enum
};

/* and more complex forms... like */

struct myEnumDesc {
    int   e_val;
    int   e_ix;
    char *e_name;
    char *e_desc;
} enum_table[] = {
#define enum(val,ix,string) val, ix, #val, string,
#include "myenumdef.i"
#undef enum
}; /* enum_table */


/* ... even, when I want to switch on them */
    switch(val) {
#define enum(val,ix,string) case VAL_##val: return string"("#val"="#ix")";
#include "myenumdef.i"
#undef enum
    default: return "invalid val";
    } /* switch */

只需用上面的方法准备一个示例，然后通过 C 预处理器运行它，看看最终的 C 代码是什么样子的。

您可以根据需要多次执行此操作（即使在单个文件中），我只需要更改宏 enum 的方式（在这种情况下，您甚至可以定义多个宏名称并将它们用于在包含数据文件之前构建更复杂的数据依赖关系。如果您想向枚举添加一个常量，您只需将其添加到.i 文件中，如上所示编码，一切都会适应变化。

您要求仅使用 C 的解决方案，因此我给出了我所知道的更近似的方式来处理同一组项目的不同定义。