关于C#：真实使用X-Macros


Real-world use of X-Macros

我刚学过X宏。你看到了x宏的实际用途吗？他们什么时候才是合适的工作工具？

相关讨论

几年前，当我开始在代码中使用函数指针时，我发现了X宏。我是一个嵌入式程序员，经常使用状态机。我经常这样写代码：

1
2
3
4
5
/* declare an enumeration of state codes */
enum{ STATE0, STATE1, STATE2, ... , STATEX, NUM_STATES};

/* declare a table of function pointers */
p_func_t jumptable[NUM_STATES] = {func0, func1, func2, ... , funcX};

问题是，我认为很容易出错，必须保持函数指针表的顺序，使其与状态枚举的顺序相匹配。

我的一个朋友向我介绍了X宏，它就像我脑袋里的灯泡熄灭了。说真的，我这辈子的X宏都在哪儿呢！

现在我定义下表：

1
2
3
4
5
6
#define STATE_TABLE \
        ENTRY(STATE0, func0) \
        ENTRY(STATE1, func1) \
        ENTRY(STATE2, func2) \
        ...
        ENTRY(STATEX, funcX) \

号

我可以使用它如下：

1
2
3
4
5
6
7
enum
{
#define ENTRY(a,b) a,
    STATE_TABLE
#undef ENTRY
    NUM_STATES
};

和

1
2
3
4
5
6
p_func_t jumptable[NUM_STATES] =
{
#define ENTRY(a,b) b,
    STATE_TABLE
#undef ENTRY
};

。

另外，我还可以让预处理器构建我的函数原型，如下所示：

1
2
3
#define ENTRY(a,b) static void b(void);
    STATE_TABLE
#undef ENTRY

另一种用法是声明和初始化寄存器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define IO_ADDRESS_OFFSET (0x8000)
#define REGISTER_TABLE\
    ENTRY(reg0, IO_ADDRESS_OFFSET + 0, 0x11)\
    ENTRY(reg1, IO_ADDRESS_OFFSET + 1, 0x55)\
    ENTRY(reg2, IO_ADDRESS_OFFSET + 2, 0x1b)\
    ...
    ENTRY(regX, IO_ADDRESS_OFFSET + X, 0x33)\

/* declare the registers (where _at_ is a compiler specific directive) */
#define ENTRY(a, b, c) volatile uint8_t a _at_ b:
    REGISTER_TABLE
#undef ENTRY

/* initialize registers */
#define ENTRY(a, b, c) a = c;
    REGISTER_TABLE
#undef ENTRY

。

不过，我最喜欢的用法是当涉及到通信处理程序时

首先，我创建一个comms表，其中包含每个命令名和代码：

1
2
3
4
5
6
#define COMMAND_TABLE \
    ENTRY(RESERVED,    reserved,    0x00) \
    ENTRY(COMMAND1,    command1,    0x01) \
    ENTRY(COMMAND2,    command2,    0x02) \
    ...
    ENTRY(COMMANDX,    commandX,    0x0X) \

。

我在表中有大小写名称，因为大小写将用于枚举，而小写将用于函数名。

然后，我还为每个命令定义结构，以定义每个命令的外观：

1
2
3
4
typedef struct {...}command1_cmd_t;
typedef struct {...}command2_cmd_t;

etc.

同样，我为每个命令响应定义结构：

1
2
3
4
typedef struct {...}command1_resp_t;
typedef struct {...}command2_resp_t;

etc.

。

然后我可以定义我的命令代码枚举：

1
2
3
4
5
6
enum
{
#define ENTRY(a,b,c) a##_CMD = c,
    COMMAND_TABLE
#undef ENTRY
};

我可以定义我的命令长度枚举：

1
2
3
4
5
6
enum
{
#define ENTRY(a,b,c) a##_CMD_LENGTH = sizeof(b##_cmd_t);
    COMMAND_TABLE
#undef ENTRY
};

。

我可以定义我的响应长度枚举：

1
2
3
4
5
6
enum
{
#define ENTRY(a,b,c) a##_RESP_LENGTH = sizeof(b##_resp_t);
    COMMAND_TABLE
#undef ENTRY
};

号

我可以确定有多少命令，如下所示：

1
2
3
4
5
6
7
8
typedef struct
{
#define ENTRY(a,b,c) uint8_t b;
    COMMAND_TABLE
#undef ENTRY
} offset_struct_t;

#define NUMBER_OF_COMMANDS sizeof(offset_struct_t)

号

注意：我从未实际实例化offset结构，我只是将它用作编译器为我生成我的命令定义数量的方法。

注意，然后我可以生成函数指针表，如下所示：

1
2
3
4
5
6
p_func_t jump_table[NUMBER_OF_COMMANDS] =
{
#define ENTRY(a,b,c) process_##b,
    COMMAND_TABLE
#undef ENTRY
}

号

我的函数原型：

1
2
3
#define ENTRY(a,b,c) void process_##b(void);
    COMMAND_TABLE
#undef ENTRY

号

最后，为了有史以来最酷的使用，我可以让编译器计算出我的传输缓冲区应该有多大。

1
2
3
4
5
6
7
/* reminder the sizeof a union is the size of its largest member */
typedef union
{
#define ENTRY(a,b,c) uint8_t b##_buf[sizeof(b##_cmd_t)];
    COMMAND_TABLE
#undef ENTRY
}tx_buf_t

号

同样，这个联合与我的offset结构类似，它没有被实例化，相反，我可以使用sizeof操作符来声明我的传输缓冲区大小。

1
uint8_t tx_buf[sizeof(tx_buf_t)];

号

现在，我的传输缓冲区tx_buf是最佳大小，当我向这个comms处理程序添加命令时，我的缓冲区将始终是最佳大小。酷！

另一种用途是创建偏移表：因为内存通常是嵌入式系统的一个约束，所以当我的跳转表是稀疏数组时，我不想使用512字节(每个指针2个字节x 256个可能的命令)。相反，我将为每个可能的命令提供一个8位偏移的表。然后，这个偏移量被用来索引到我的实际跳转表中，这个表现在只需要是num_commands*sizeof(指针)。在我的例子中，定义了10个命令。我的跳转表是20字节长，我有一个256字节长的偏移表，总共是276字节，而不是512字节。然后我这样调用我的函数：

1
jump_table[offset_table[command]]();

号

而不是

1
jump_table[command]();

号

我可以创建这样的偏移表：

1
2
3
4
5
6
7
/* initialize every offset to 0 */
static uint8_t offset_table[256] = {0};

/* for each valid command, initialize the corresponding offset */
#define ENTRY(a,b,c) offset_table[c] = offsetof(offset_struct_t, b);
    COMMAND_TABLE
#undef ENTRY

号

其中offsetof是"stddef.h"中定义的标准库宏

另一个好处是，有一种非常简单的方法可以确定命令代码是否受支持：

1
2
3
4
5
bool command_is_valid(uint8_t command)
{
    /* return false if not valid, or true (non 0) if valid */
    return offset_table[command];
}

这也是为什么在我的命令_表中我保留了命令字节0。我可以创建一个名为"process_reserved()"的函数，如果使用任何无效的命令字节索引到我的offset表，将调用该函数。

相关讨论

X宏本质上是参数化模板。因此，如果您需要以多种形式的几个类似的东西，那么它们是适合该工作的工具。它们允许您创建一个抽象形式，并根据不同的规则对其进行实例化。

我使用x宏将枚举值输出为字符串。由于遇到了它，我非常喜欢使用"用户"宏应用于每个元素的表单。多文件包含只是更痛苦的工作。

1
2
3
4
5
6
7
8
9
10
11
12
13
/* x-macro constructors for error and type
   enums and string tables */
#define AS_BARE(a) a ,
#define AS_STR(a) #a ,

#define ERRORS(_) \
    _(noerror) \
    _(dictfull) _(dictstackoverflow) _(dictstackunderflow) \
    _(execstackoverflow) _(execstackunderflow) _(limitcheck) \
    _(VMerror)
enum err { ERRORS(AS_BARE) };
char *errorname[] = { ERRORS(AS_STR) };
/* puts(errorname[(enum err)limitcheck]); */

我还使用它们根据对象类型进行函数调度。再次劫持我用来创建枚举值的同一个宏。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define TYPES(_) \
    _(invalid) \
    _(null) \
    _(mark) \
    _(integer) \
    _(real) \
    _(array) \
    _(dict) \
    _(save) \
    _(name) \
    _(string) \
/*enddef TYPES */

#define AS_TYPE(_) _ ## type ,
enum { TYPES(AS_TYPE) };

号

使用宏可以确保所有数组索引都与关联的枚举值匹配，因为它们使用宏定义(types宏)中的裸标记构造其各种形式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
typedef void evalfunc(context *ctx);

void evalquit(context *ctx) { ++ctx->quit; }

void evalpop(context *ctx) { (void)pop(ctx->lo, adrent(ctx->lo, OS)); }

void evalpush(context *ctx) {
    push(ctx->lo, adrent(ctx->lo, OS),
            pop(ctx->lo, adrent(ctx->lo, ES)));
}

evalfunc *evalinvalid = evalquit;
evalfunc *evalmark = evalpop;
evalfunc *evalnull = evalpop;
evalfunc *evalinteger = evalpush;
evalfunc *evalreal = evalpush;
evalfunc *evalsave = evalpush;
evalfunc *evaldict = evalpush;
evalfunc *evalstring = evalpush;
evalfunc *evalname = evalpush;

evalfunc *evaltype[stringtype/*last type in enum*/+1];
#define AS_EVALINIT(_) evaltype[_ ## type] = eval ## _ ;
void initevaltype(void) {
    TYPES(AS_EVALINIT)
}

void eval(context *ctx) {
    unsigned ades = adrent(ctx->lo, ES);
    object t = top(ctx->lo, ades, 0);
    if ( isx(t) ) /* if executable */
        evaltype[type(t)](ctx);  /* <--- the payoff is this line here! */
    else
        evalpush(ctx);
}

以这种方式使用X宏实际上有助于编译器提供有用的错误消息。我忽略了上面的evalarray函数，因为它会分散我的注意力。但是，如果您试图编译上述代码(注释掉其他函数调用，并为上下文提供一个伪typedef)，编译器会抱怨缺少的函数。对于我添加的每个新类型，当我重新编译此模块时，会提醒我添加一个处理程序。因此，x宏有助于确保并行结构在项目增长时保持完整。

编辑：

这个答案使我的声誉提高了50%。这里还有一点。下面是一个否定的例子，回答了这个问题：什么时候不使用X宏？

这个例子显示了将任意代码片段打包到X-"记录"中。我最终放弃了这个项目的分支，并没有在以后的设计中使用这个策略(也不是因为缺乏尝试)。不知怎么地，它变得不受欢迎。实际上，宏的名称是X6，因为有一次有6个参数，但我厌倦了更改宏名称。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/* Object types */
/*"'X'" macros for Object type definitions, declarations and initializers */
// a                      b            c              d
// enum,                  string,      union member,  printf d
#define OBJECT_TYPES \
X6(    nulltype,       "null",     int dummy      ,            ("<null>")) \
X6(    marktype,       "mark",     int dummy2      ,           ("<mark>")) \
X6( integertype,    "integer",     int  i,     ("%d",o.i)) \
X6( booleantype,    "boolean",     bool b,     (o.b?"true":"false")) \
X6(    realtype,       "real",     float f,        ("%f",o.f)) \
X6(    nametype,       "name",     int  n,     ("%s%s", \
        (o.flags & Fxflag)?"":"/", names[o.n])) \
X6(  stringtype,     "string",     char *s,        ("%s",o.s)) \
X6(    filetype,       "file",     FILE *file,     ("<file %p>",(void *)o.file)) \
X6(   arraytype,      "array",     Object *a,      ("",o.length)) \
X6(    dicttype,       "dict",     struct s_pair *d, ("<dict %u>",o.length)) \
X6(operatortype,   "operator",     void (*o)(),    ("<op>")) \

#define X6(a, b, c, d) #a,
char *typestring[] = { OBJECT_TYPES };
#undef X6

// the Object type
//forward reference so s_object can contain s_objects
typedef struct s_object Object;

// the s_object structure:
// a bit convoluted, but it boils down to four members:
// type, flags, length, and payload (union of type-specific data)
// the first named union member is integer, so a simple literal object
// can be created on the fly:
// Object o = {integertype,0,0,4028}; //create an int object, value: 4028
// Object nl = {nulltype,0,0,0};
struct s_object {
#define X6(a, b, c, d) a,
    enum e_type { OBJECT_TYPES } type;
#undef X6
unsigned int flags;
#define Fread  1
#define Fwrite 2
#define Fexec  4
#define Fxflag 8
size_t length; //for lint, was: unsigned int
#define X6(a, b, c, d) c;
    union { OBJECT_TYPES };
#undef X6
};

。

一个大问题是printf格式字符串。虽然看起来很酷，但这只是个骗局。因为它只在一个函数中使用，所以宏的过度使用实际上分离了应该在一起的信息；并且它使函数本身不可读。在像这样的调试函数中，混淆是加倍不幸的。

1
2
3
4
5
6
7
8
9
10
//print the object using the type's format specifier from the macro
//used by O_equal (ps: =) and O_equalequal (ps: ==)
void printobject(Object o) {
    switch (o.type) {
#define X6(a, b, c, d) \
        case a: printf d; break;
OBJECT_TYPES
#undef X6
    }
}

所以不要太激动。就像我一样。

在Oracle热点虚拟机中为JAVA？编程语言，有文件globals.hpp，它以这种方式使用RUNTIME_FLAGS。

请参见源代码：

  • JDK 7
  • JDK 8
  • JDK 9
相关讨论

我喜欢使用x宏来创建"富枚举"，它支持迭代枚举值以及获取每个枚举值的字符串表示形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#define MOUSE_BUTTONS \
X(LeftButton, 1)   \
X(MiddleButton, 2) \
X(RightButton, 4)

struct MouseButton {
  enum Value {
    None = 0
#define X(name, value) ,name = value
MOUSE_BUTTONS
#undef X
  };

  static const int *values() {
    static const int a[] = {
      None,
#define X(name, value) name,
    MOUSE_BUTTONS
#undef X
      -1
    };
    return a;
  }

  static const char *valueAsString( Value v ) {
#define X(name, value) static const char str_##name[] = #name;
MOUSE_BUTTONS
#undef X
    switch ( v ) {
      case None: return"None";
#define X(name, value) case name: return str_##name;
MOUSE_BUTTONS
#undef X
    }
    return 0;
  }
};

。

这不仅定义了一个MouseButton::Value枚举，它还允许我执行如下操作

1
2
3
4
5
// Print names of all supported mouse buttons
for ( const int *mb = MouseButton::values(); *mb != -1; ++mb ) {
    std::cout << MouseButton::valueAsString( (MouseButton::Value)*mb ) <<"
";
}

号

我使用相当大的x宏将ini文件的内容加载到配置结构中，其中包括围绕该结构旋转的其他内容。

这就是我的"configuration.def"-文件的外观：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define NMB_DUMMY(...) X(__VA_ARGS__)
#define NMB_INT_DEFS \
   TEXT("long int") , long , , , GetLongValue , _ttol , NMB_SECT , SetLongValue ,

#define NMB_STR_DEFS NMB_STR_DEFS__(TEXT("string"))
#define NMB_PATH_DEFS NMB_STR_DEFS__(TEXT("path"))

#define NMB_STR_DEFS__(ATYPE) \
  ATYPE ,  basic_string<TCHAR>* , new basic_string<TCHAR>\
  , delete , GetValue , , NMB_SECT , SetValue , *

/* X-macro starts here */

#define NMB_SECT"server"
NMB_DUMMY(ip,TEXT("Slave IP."),TEXT("10.11.180.102"),NMB_STR_DEFS)
NMB_DUMMY(port,TEXT("Slave portti."),TEXT("502"),NMB_STR_DEFS)
NMB_DUMMY(slaveid,TEXT("Slave protocol ID."),0xff,NMB_INT_DEFS)
.
. /* And so on for about 40 items. */

我承认，这有点令人困惑。很快我就明白了，我实际上并不想在每个字段宏之后编写所有这些类型声明。(别担心，有一个大评论可以解释我为了简洁而忽略的所有内容。)

这就是我如何声明配置结构：

1
2
3
4
5
6
7
typedef struct {
#define X(ID,DESC,DEFVAL,ATYPE,TYPE,...) TYPE ID;
#include"configuration.def"
#undef X
  basic_string<TCHAR>* ini_path;  //Where all the other stuff gets read.
  long verbosity;                 //Used only by console writing functions.
} Config;

号

然后，在代码中，首先将默认值读取到配置结构中：

1
2
3
4
#define X(ID,DESC,DEFVAL,ATYPE,TYPE,CONSTRUCTOR,DESTRUCTOR,GETTER,STRCONV,SECT,SETTER,...) \
  conf->ID = CONSTRUCTOR(DEFVAL);
#include"configuration.def"
#undef X

然后，使用library simpleini将ini读取到配置结构中，如下所示：

1
2
3
4
5
6
7
#define X(ID,DESC,DEFVAL,ATYPE,TYPE,CONSTRUCTOR,DESTRUCTOR,GETTER,STRCONV,SECT,SETTER,DEREF...)\
  DESTRUCTOR (conf->ID);\
  conf->ID  = CONSTRUCTOR( ini.GETTER(TEXT(SECT),TEXT(#ID),DEFVAL,FALSE) );\
  LOG3A(<< left << setw(13) << TEXT(#ID) << TEXT(":")  << left << setw(30)\
    << DEREF conf->ID << TEXT(" (") << DEFVAL << TEXT(").") );
#include"configuration.def"
#undef X

。

命令行标志中的重写也使用相同的名称(GNU长格式)格式化，使用library simpleopt以如下方式应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
enum optflags {
#define X(ID,...) ID,
#include"configuration.def"
#undef X
  };
  CSimpleOpt::SOption sopt[] = {
#define X(ID,DESC,DEFVAL,ATYPE,TYPE,...) {ID,TEXT("--") #ID TEXT("="), SO_REQ_CMB},
#include"configuration.def"
#undef X
    SO_END_OF_OPTIONS
  };
  CSimpleOpt ops(argc,argv,sopt,SO_O_NOERR);
  while(ops.Next()){
    switch(ops.OptionId()){
#define X(ID,DESC,DEFVAL,ATYPE,TYPE,CONSTRUCTOR,DESTRUCTOR,GETTER,STRCONV,SECT,...) \
  case ID:\
    DESTRUCTOR (conf->ID);\
    conf->ID = STRCONV( CONSTRUCTOR (  ops.OptionArg() ) );\
    LOG3A(<< TEXT("Omitted")<<left<<setw(13)<<TEXT(#ID)<<TEXT(" :")<<conf->ID<<TEXT(" ."));\
    break;
#include"configuration.def"
#undef X
    }
  }

等等，我还使用相同的宏来打印--help-flag输出和示例默认in i文件，configuration.def在我的程序中包含了8次。"方钉入一个圆孔"，也许；一个真正称职的程序员会如何处理这个问题？大量的循环和字符串处理？

网址：https://github.com/whunmr/dataex

我使用下面的xMigs生成一个C++类，其中包含序列化和反序列化的内置函数。

1
2
3
4
5
6
7
8
9
10
#define __FIELDS_OF_DataWithNested(_)  \
  _(1, a, int  )                       \
  _(2, x, DataX)                       \
  _(3, b, int  )                       \
  _(4, c, char )                       \
  _(5, d, __array(char, 3))            \
  _(6, e, string)                      \
  _(7, f, bool)

DEF_DATA(DataWithNested);

。

用途：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
TEST_F(t, DataWithNested_should_able_to_encode_struct_with_nested_struct) {
    DataWithNested xn;
    xn.a = 0xCAFEBABE;
    xn.x.a = 0x12345678;
    xn.x.b = 0x11223344;
    xn.b = 0xDEADBEEF;
    xn.c = 0x45;
    memcpy(&xn.d,"XYZ", strlen("XYZ"));

    char buf_with_zero[] = {0x11, 0x22, 0x00, 0x00, 0x33};
    xn.e = string(buf_with_zero, sizeof(buf_with_zero));
    xn.f = true;

    __encode(DataWithNested, xn, buf_);

    char expected[] = { 0x01, 0x04, 0x00, 0xBE, 0xBA, 0xFE, 0xCA,
                        0x02, 0x0E, 0x00 /*T and L of nested X*/,
                        0x01, 0x04, 0x00, 0x78, 0x56, 0x34, 0x12,
                        0x02, 0x04, 0x00, 0x44, 0x33, 0x22, 0x11,
                        0x03, 0x04, 0x00, 0xEF, 0xBE, 0xAD, 0xDE,
                        0x04, 0x01, 0x00, 0x45,
                        0x05, 0x03, 0x00, 'X', 'Y', 'Z',
                        0x06, 0x05, 0x00, 0x11, 0x22, 0x00, 0x00, 0x33,
                        0x07, 0x01, 0x00, 0x01};

    EXPECT_TRUE(ArraysMatch(expected, buf_));
}

。

另外，另一个例子是https://github.com/whunmr/msgrpc。