将字符串添加到 C 预处理器列表中的每个元素？

Question

最终，我想要的是：首先，有一个声明为 C 预处理器宏的变量名列表； 比如说，在test_cpp.c中：

#define VARLIST \
  var_one, \
  var_two, \
  var_three, \
  var_four

这些最终将成为代码中的实际变量名——但是，当然，预处理器此时不知道（甚至没有概念）。

为确保宏已被正确解析，我使用此命令（ awk删除gcc -E预处理器输出中定义的前导码）：

$ gcc -E -dD test_cpp.c | awk 'BEGIN{prn=0} /# 1 "test_cpp.c"/ {prn=1} prn==1 {print}'
# 1 "test_cpp.c"

#define VARLIST var_one, var_two, var_three, var_four

到目前为止，一切都很好。

现在：其次，我想使用这个列表 - 也就是说，我想（预）处理它 - 并在 VARLIST 的每个元素（标记）前加上 append 个字符，这样我最终得到等价的以下宏：

#define VARLIST_QUOTED "var_one", "var_two", "var_three", "var_four"
#define VARLIST_PTR &var_one, &var_two, &var_three, &var_four

...我最终可以在代码中使用它，比如：

char varnames[][16] = { VARLIST_QUOTED };

（......然后在编译代码中最终会像这样，在调试器中检查：

(gdb) p varnames
$1 = {"var_one\000\000\000\000\000\000\000\000", 
  "var_two\000\000\000\000\000\000\000\000", 
  "var_three\000\000\000\000\000\000", 
  "var_four\000\000\000\000\000\000\000"}

)

我猜，此时预处理器不知道&打算成为“寻址”运算符，尽管我认为它对双引号有特殊处理。

无论如何，我认为预处理器中的此类“列表”是通过Variadic Macros (The C Preprocessor)处理的，其中有一个标识符__VA_ARGS__ 。 不幸的是，我不太了解这一点：我尝试了想到的第一件事 - 再次， test_cpp.c ：

#define VARLIST \
  var_one, \
  var_two, \
  var_three, \
  var_four

#define do_prepend(...) &##__VA_ARGS__
#define VARLIST_PTR do_prepend(VARLIST)

void* vars_ptr[] = { VARLIST_PTR };

然后如果我运行预处理器，我会得到这个：

$ gcc -E -dD test_cpp.c | awk 'BEGIN{prn=0} /# 1 "test_cpp.c"/ {prn=1} prn==1 {print}' | sed '/^$/d;G'
test_cpp.c:8:25: error: pasting "&" and "VARLIST" does not give a valid preprocessing token
    8 | #define do_prepend(...) &##__VA_ARGS__
      |                         ^
test_cpp.c:9:21: note: in expansion of macro 'do_prepend'
    9 | #define VARLIST_PTR do_prepend(VARLIST)
      |                     ^~~~~~~~~~
test_cpp.c:11:22: note: in expansion of macro 'VARLIST_PTR'
   11 | void* vars_ptr[] = { VARLIST_PTR };
      |                      ^~~~~~~~~~~
# 1 "test_cpp.c"

#define VARLIST var_one, var_two, var_three, var_four

#define do_prepend(...) & ##__VA_ARGS__

#define VARLIST_PTR do_prepend(VARLIST)

void* vars_ptr[] = { &var_one, var_two, var_three, var_four };

它确实显示了一个错误——但最终，预处理器确实在数组vars_ptr的第一个变量前添加了一个&符号，正如我希望的那样……

那么问题是：它是否可以在列表VARLIST中的所有条目前面添加一个&而没有错误（同样，它是否可以在列表VARLIST中的所有条目前面添加一个双引号"和append 而没有错误） - 如果又怎样？

Answer 1

听起来像是 X 宏的工作：

#include <stdio.h>

#define VARS \
  X(var_one) \
  X(var_two) \
  X(var_three) \
  X(var_four)

// Define all the variables as ints (just for the example)
#define X(V) int V=0;
VARS
#undef X

// Define the array of variable pointers
#define X(V) &V,
void* vars_ptr[] = { VARS };
#undef X

// Define the array of variable name strings
#define X(V) #V,
const char *var_names[] = { VARS };
#undef X

// Set a few variable values and print out the name/value of all variables
int main()
{
    var_one = 9;
    var_two = 2;
    for(unsigned i = 0; i < sizeof(var_names)/sizeof(var_names[0]); i++)
    {
        printf("%s=%d\n", var_names[i], *(int *)vars_ptr[i]);
    }

    return 0;
}

Answer 2

好吧，我似乎找到了答案，主要是感谢Is it possible to iterate over arguments in variadic macros? （另请参阅在宏中展开宏）； 这是test_cpp.c ：

#define VARLIST \
  var_one, \
  var_two, \
  var_three, \
  var_four


// Make a FOREACH macro
#define FE_0(WHAT)
#define FE_1(WHAT, X) WHAT(X) 
#define FE_2(WHAT, X, ...) WHAT(X)FE_1(WHAT, __VA_ARGS__)
#define FE_3(WHAT, X, ...) WHAT(X)FE_2(WHAT, __VA_ARGS__)
#define FE_4(WHAT, X, ...) WHAT(X)FE_3(WHAT, __VA_ARGS__)
#define FE_5(WHAT, X, ...) WHAT(X)FE_4(WHAT, __VA_ARGS__)
//... repeat as needed

#define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME 
#define FOR_EACH(action,...) \
  GET_MACRO(_0,__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1,FE_0)(action,__VA_ARGS__)

#define XSTR(x) STR(x)
#define STR(x) #x

// original: https://stackoverflow.com/a/11994395
//#define QUALIFIER(X) X::
//#define QUALIFIED(NAME,...) FOR_EACH(QUALIFIER,__VA_ARGS__)NAME

#define POINTERER(X) &X,
#define POINTERIFIED(NAME,...) FOR_EACH(POINTERER,__VA_ARGS__)NAME

// leave first argument (from original QUALIFIED) empty here!
#define vptrs POINTERIFIED(,VARLIST) 

void* vars_ptr[] = { vptrs };

//#define DQUOTE " // no need for DQUOTE;
// if we just use the number/hash sign, X gets automatically quoted with double quotes!
// (don't forget the comma at the end!)
#define DQUOTERER(X) #X,
#define DQUOTERIFIED(NAME,...) FOR_EACH(DQUOTERER,__VA_ARGS__)NAME

// leave first argument (from original QUALIFIED) empty here!
#define vnames DQUOTERIFIED(,VARLIST) 
char vars_names[][16] = { vnames };

...这是预处理器的 output：

$ gcc -E -dD test_cpp.c | awk 'BEGIN{prn=0} /# 1 "test_cpp.c"/ {prn=1} prn==1 {print}' | sed '/^$/d;G'
# 1 "test_cpp.c"

#define VARLIST var_one, var_two, var_three, var_four

#define FE_0(WHAT)

#define FE_1(WHAT,X) WHAT(X)

#define FE_2(WHAT,X,...) WHAT(X)FE_1(WHAT, __VA_ARGS__)

#define FE_3(WHAT,X,...) WHAT(X)FE_2(WHAT, __VA_ARGS__)

#define FE_4(WHAT,X,...) WHAT(X)FE_3(WHAT, __VA_ARGS__)

#define FE_5(WHAT,X,...) WHAT(X)FE_4(WHAT, __VA_ARGS__)

#define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME

#define FOR_EACH(action,...) GET_MACRO(_0,__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1,FE_0)(action,__VA_ARGS__)

#define XSTR(x) STR(x)

#define STR(x) #x

#define POINTERER(X) &X,

#define POINTERIFIED(NAME,...) FOR_EACH(POINTERER,__VA_ARGS__)NAME

#define vptrs POINTERIFIED(,VARLIST)

void* vars_ptr[] = { &var_one,&var_two,&var_three,&var_four, };

#define DQUOTERER(X) #X,

#define DQUOTERIFIED(NAME,...) FOR_EACH(DQUOTERER,__VA_ARGS__)NAME

#define vnames DQUOTERIFIED(,VARLIST)

char vars_names[][16] = { "var_one","var_two","var_three","var_four", };

所以，最终，我得到了我想要的 output - 据我所知，没有预处理器错误/警告：

void* vars_ptr[] = { &var_one,&var_two,&var_three,&var_four, };
char vars_names[][16] = { "var_one","var_two","var_three","var_four", };

Answer 3

如前所述，您或多或少地在字面上描述“X 宏”的目的。

另一种可以说更具可读性的编写方法是首先声明一个宏列表，然后将宏传递给该列表。 如在

• “这是一个类似函数的宏，用列出的所有 arguments 运行它”，而不是
• “这里是类似函数的宏 X，运行宏 X 并列出所有 arguments”。

这允许您为宏赋予有意义的名称，可以选择将属于列表的所有宏分组在某处，并且它消除了#undef的需要。

#include <stdio.h>

// note the absence of commas
#define VARLIST(X) \
  X(var_one)       \
  X(var_two)       \
  X(var_three)     \
  X(var_four)      \

int main (void)
{
  char varnames[][16] =
  {
    #define VARLIST_QUOTED(name) #name, /* "stringification operator" */
    VARLIST(VARLIST_QUOTED) /* no semicolon or comma here */
  };
  
  #define VARLIST_DECL_VARS(name) int name; /* declare a bunch of int */
  VARLIST(VARLIST_DECL_VARS)

  int* const pointers[] = 
  {
    #define VARLIST_PTR(name) &name, /* declare an array of pointers to previous ints */
    VARLIST(VARLIST_PTR)
  };

  var_two = 123;
  printf("%s has value %d and address %p\n", 
         varnames[1], 
         var_two, 
         pointers[1]);
}