【问题标题】:Write vargarg C preprocessor macro which calls some other macro with each of its arguments and more编写 vargarg C 预处理器宏,该宏使用其每个参数和更多参数调用其他宏
【发布时间】:2017-12-08 04:28:45
【问题描述】:

我需要在我的代码中包含有关结构的元信息。因此,我编写了一些 C 结构(用于存储元信息)和 C 预处理器宏的组合来初始化这些结构,而无需太多样板代码。现在看起来像这样(真的,我存储了更多关于字段的信息,但是这段代码足以解决我的问题):

#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>

struct meta_field {
  const char *name;
  size_t offset;
};

struct meta_struct {
  const char *name;
  size_t size;
  struct meta_field fields[];
};

#define META_STRUCT_BEGIN(NAME)               \
  static struct meta_struct s_meta_##NAME = { \
    .name = "" #NAME,                         \
    .size = sizeof(struct NAME),              \
    .fields = {
#define META_STRUCT_END()  ,{NULL, 0}}}
#define META_FIELD(NAME)   { .name = "" #NAME, .offset = offsetof(struct CURRENT_META_STRUCT, NAME) }


struct example {
  int i;
  double d;
};

#define CURRENT_META_STRUCT example
META_STRUCT_BEGIN(CURRENT_META_STRUCT)
  META_FIELD(i),
  META_FIELD(d)
META_STRUCT_END();
#undef CURRENT_META_STRUCT

它有效。但它仍然有很多样板:#define CURRENT_META_STRUCT,CURRENT_META_STRUCT 的用法作为META_STRUCT_BEGIN() 的参数,#undef 用于CURRENT_META_STRUCT — 所有这些看起来都很难看,恕我直言。

我知道,不可能逐个定义宏(所以,META_STRUCT_BEGIN() 不能定义 CURRENT_META_STRUCT)。但是看看 C Preprocessor 和 Boost-PP 中的 Branf*ck 实现,我认为实现如下所示的东西是可能的:

META_STRUCT(example,
  META_FIELD(i),
  META_FIELD(d)
)

但我无法理解这个预处理器的魔法。

有人可以帮我吗?

我已经阅读了https://github.com/orangeduck/CPP_COMPLETE,但没有帮助。

此外,它被标记为与this 重复,但问题是我需要为所有生成的宏“调用”添加“默认”参数。

这是一些草图,我想要实现的目标:

#define META_FIELD_IMPL(STRUCT, NAME) { .name = "" #NAME, .offset = offsetof(struct STRUCT, NAME) }

#define META_FIELD(NAME)  NAME

#define META_STRUCT(NAME, ... )               \
  static struct meta_struct s_meta_##NAME = { \
    .name = "" #NAME,                         \
    .size = sizeof(struct NAME),              \
    .fields = {                               \
      /* Each ARG from __VA_ARGS__ is META_FIELD(x) and                 \
       * I need to call META_FIELD_IMPL(NAME, <Expansion of META_FIELD>) \
       * for each ARG from _VA_ARGS_ here */                            \
      {NULL, 0}                               \
     }}

现在在这个例子中,META_FIELD() 只有一个参数:NAME,但在实际系统中,META_FIELD() 有 6 个参数和一些为常见情况提供“默认”值的辅助宏,所以 @987654338 @ 是必需的,不能被 NAME 本身代替。

最后一个复杂的情况是:这样的META_STRUCT() 可以作为META_FIELD() 的参数调用,因为某些字段包含指向嵌套元结构的指针!现在它是通过为所有嵌套子结构声明命名对象来完成的,但我也想避免它!我明白,嵌套的深度可能会受到一些任意常数的限制,没关系。

更新:我添加了这个示例,说明我想输入什么以及在预处理器之后我想得到什么。我不知道如何实现所有这些宏(标有/* ??? */)。而且,是的,我已经检查过,手动编码的“最终结果”编译得很好。

enum meta_type { mt_end, mt_int, mt_string, mt_struct };

struct meta_struct;

struct meta_field {
  const char *name;
  enum meta_type type;
  size_t offset;
  struct meta_struct *child;
};

struct meta_struct {
  const char *name;
  size_t size;
  struct meta_field *fields;
};

#define META_STRUCT(NAME, ...)  static struct meta_struct s_meta_##name = { .name = #NAME, .size = sizeof(struct NAME), .fileds = (struct meta_field[]){ /* ??? */, {NULL, mt_end, 0, NULL}}}
#define META_FIELD_IMPL0(STRUCT, NAME, TYPE, CHILD) { .name = #NAME, .type = TYPE, .offset = offsetof(STRUCT, NAME), .child = CHILD }
#define META_FIELD_IMPL1(NAME, TYPE, CHILD)  /* ??? */

#define META_FIELD(NAME, TYPE)       META_FIELD_IMPL1(NAME, TYPE, NULL)
#define META_FIELD_SUB(NAME, CHILD)  META_FIELD_IMPL1(NAME, mt_struct, CHILD)
#define META_SUBSTRUCT(NAME, ...)  (struct meta_struct){ .name = #NAME, .size = sizeof(struct NAME), .fileds = (struct meta_field[]){ /* ??? */, {NULL, mt_end, 0, NULL}}}

/* Example of "input": */
struct child {
  int i;
};

struct parent {
  int i;
  struct child c;
  const char *s;
};

META_STRUCT(parent,
  META_FIELD(i, mt_int),
  META_FIELD_SUB(c, 
    META_SUBSTRUCT(child,
      META_FIELD(i, mt_int)
    )
  ),
  META_FIELD(s, mt_string)
);

/* This should give this */
static struct meta_struct s_meta_parent = {
  .name = "parent",
  .size = sizeof(struct parent),
  .fields = (struct meta_field[]) {
    { .name = "i", .type = mt_int, .offset = offsetof(struct parent, i), .child = NULL },
    { .name = "c", .type = mt_struct, .offset = offsetof(struct parent, c), .child = &(struct meta_struct){
        .name = "child",
        .size = sizeof(struct child),
        .fields = (struct meta_field[]) {
          { .name = "i", .type = mt_int, .offset = offsetof(struct child, i), .child = NULL },
          {NULL, mt_end, 0, NULL}
        }
      }
    },
    { .name = "s", .type = mt_string, .offset = offsetof(struct parent, s), .child = NULL },
    {NULL, mt_end, 0, NULL}
  }
};

【问题讨论】:

  • 必须看起来像META_STRUCT(example, META_FIELD(i), META_FIELD(d))吗?会不会看起来像 META_STRUCT(example, i, d) 或 META_STRUCT(example, (i, d))?
  • @h-walters 这是简化的示例,正​​如我所提到的。实际上 META_FILED 有几个参数(其中 6 个),这里有一些辅助宏,用于默认一些参数,如 META_FIELD_INT8(name)、META_FIELD_STRING() 等。它映射到简单的名称列表很糟糕。
  • 当然嵌套的META_STRUCT 宏不能相同,因为它们应该扩展为不同的东西? (我不希望在初始化程序中间看到static struct meta_struct s_meta_##NAME ={)。

标签: c c-preprocessor preprocessor-directive


【解决方案1】:

使用__VA_ARGS__怎么样?下面的 Codesnip 接受最大化 4 个字段,但您可以通过复制并粘贴一些代码行来扩展到 5、6 或更多(请参阅 here 了解更多详细信息)。

头文件:

#define META_FIELD1(st,x1) { .name = #x1, .offset = offsetof(struct st, x1) }
#define META_FIELD2(st,x1,x2) META_FIELD1(st,x1), META_FIELD1(st, x2)
#define META_FIELD3(st,x1,x2,x3) META_FIELD1(st,x1), META_FIELD2(st,x2,x3)
#define META_FIELD4(st,x1,x2,x3,x4) META_FIELD1(st,x1), META_FIELD3(st,x2,x3,x4)
#define META_FIELD(st, ...)     META_FIELD4(st, ##__VA_ARGS__) // limit to 4

#define META_STRUCT(st, ...) \
    static struct meta_struct meta_struct_##st = { \
        .name = #st, \
        .size = sizeof(struct st), \
        .fields = { \
            META_FIELD(st, ##__VA_ARGS__) \
        } \
    } \

C 文件:

struct sample {
    int i;
    double d;
    const char *test;
    float t;
};

META_STRUCT(sample, i, d, test, t);

/*
 * 
 */
int main(int argc, char** argv) {
    printf("struct %s { %s, %s, %s, %s } \n", 
            meta_struct_sample.name, 
            meta_struct_sample.fields[0].name, 
            meta_struct_sample.fields[1].name, 
            meta_struct_sample.fields[2].name, 
            meta_struct_sample.fields[3].name);

    return (EXIT_SUCCESS);
}

输出应该是:struct sample { i, i, test, t }

【讨论】:

  • 首先,据我所知,##__VA_ARGS__ 是 gcc 扩展。它不是便携式的。其次,它很简单,每个字段只有一个参数(名称)。如果您添加第二个、第三个等 - 这个简单的解决方案不再起作用或变得丑陋(字段参数进入一个参数列表)。
【解决方案2】:

这是一种方法。

基本实用程序

#define GLUE(A,B) GLUE_I(A,B)
#define GLUE_I(A,B) A##B
#define COUNT(...) COUNT_I(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
#define COUNT_I(V,_9,_8,_7,_6,_5,_4,_3,_2,X,...) X

这是一个间接粘合宏(允许扩展参数)和一个计数宏。这里的 count 宏只支持 9 个参数,但是很容易扩展模式。这只是扩展到传递的参数数量。我假设你以前见过这个,但万一你没有,这只是通过参数转移来工作;它间接扩展了参数,并且每个额外的参数移到 1 以上都会替换数字列表,直到某个东西“高于”X,它会扩展到它。

#define FIRST(...) FIRST_I(__VA_ARGS__,)
#define FIRST_I(X,...) X
#define REST(X,...) __VA_ARGS__
#define EXPAND(...) __VA_ARGS__

...这些是对元组的操作。出于此答案的目的,tuple 是括号中的一组标记。 FIRST 和 REST 使用元组作为数据类型(应该很明显;FIRST 间接获取第一个元素,REST 扩展到除此之外的所有元素)。 EXPAND 解开一个元组。

还有下一个实用宏:

#define FOREACH(MACRO_,DATA_,TUPLE_) GLUE(FOREACH_I_,COUNT TUPLE_)(MACRO_,DATA_,TUPLE_)

#define FOREACH_I_1(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_)
#define FOREACH_I_2(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_1(MACRO_,DATA_,(REST TUPLE_))
#define FOREACH_I_3(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_2(MACRO_,DATA_,(REST TUPLE_))
#define FOREACH_I_4(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_3(MACRO_,DATA_,(REST TUPLE_))
#define FOREACH_I_5(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_4(MACRO_,DATA_,(REST TUPLE_))
#define FOREACH_I_6(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_5(MACRO_,DATA_,(REST TUPLE_))
#define FOREACH_I_7(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_6(MACRO_,DATA_,(REST TUPLE_))
#define FOREACH_I_8(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_7(MACRO_,DATA_,(REST TUPLE_))
#define FOREACH_I_9(MACRO_,DATA_,TUPLE_) MACRO_(DATA_,FIRST TUPLE_) FOREACH_I_8(MACRO_,DATA_,(REST TUPLE_))

这是关键宏;它实际上用于将结构的类型应用到每个字段的较低级别的宏中。同样,此特定代码每个级别仅适用于 9 个字段,但如何扩展它应该很明显(您可能希望支持 COUNT 宏可以计数的尽可能多的级别)。

FOREACH 的第三个参数应该是一个元组; FOREACH 的工作是在 DATA_ 和 TUPLE_ 的每个元素上调用您的宏。例如,FOREACH(FIELD,parent,(i,j,k)) 扩展为 FIELD(parent,i) FIELD(parent,j) FIELD(parent,k)。

特定实用程序的概念

特定实用程序的核心调用结构使用元组数据类型;当与FOREACH 宏一起使用时,底层调用将适当地将外部结构类型curry 到每个调用中。调用结构如下:

<b>META_STRUCT(</b>type <b>,</b> FIELD[ <b>,</b> FIELD[ ... ] ] <b>)</b>

...每个FIELD 是一个三元组:

<b>(</b>name <b>,</b> type <b>,</b> CHILD <b>)</b>

...每个CHILD 是一个元组,它被扩展为一个.child 赋值。 META_SUBSTRUCT 的工作原理类似。所以根据这个调用结构,你的例子实际上会被这样调用:

META_STRUCT(parent, (i, mt_int, (NULL)), (c, mt_struct, META_SUBSTRUCT(child,(i,mt_int,(NULL)))),(s, mt_string, (NULL)));

在实践中,META_SUBSTRUCT 实际上会完全扩展。它的扩展将是一个充当子分配的“令牌元组”;也就是说,META_SUBSTRUCT 将扩展为用括号括起来的子结构中的实际分配。 FOREACH 宏应用于此构造,将上述 3 元组的外部结构和三个参数柯化到 4 参数宏 APPLY_UTILI_FIELD。

用法反映了您的用法并采用了这种调用结构。例如,META_FIELD(i, mt_int) 只是一个扩展为 (i, mt_int, (NULL)) 的宏。

特定实用程序

#define META_STRUCT_BEGIN(NAME_) \
   static struct meta_struct s_meta_##NAME_ = {  \
      .name = #NAME_,  \
      .size = sizeof(struct NAME_),  \
      .fields = (struct meta_field[]) { 

#define META_STRUCT(NAME_,...) \
   META_STRUCT_BEGIN(NAME_) \
      FOREACH(APPLY_META_STRUCT_MACRO,NAME_,(__VA_ARGS__)) \
   META_STRUCT_END()

#define META_STRUCT_END()  \
         {NULL, mt_end, 0, NULL}}}

#define META_SUBSTRUCT(NAME_,...) \
   ( META_SUBSTRUCT_BEGIN(NAME_) \
        FOREACH(APPLY_META_STRUCT_MACRO,NAME_,(__VA_ARGS__)) \
     META_SUBSTRUCT_END() )

#define META_SUBSTRUCT_BEGIN(NAME_) \
   &(struct meta_struct) { \
      .name = #NAME_, \
      .size = sizeof(struct NAME_), \
      .fields = (struct meta_field[]) {

#define META_SUBSTRUCT_END() \
    {NULL, mt_end, 0, NULL}}}

#define APPLY_META_STRUCT_MACRO(DATA_, ARG_) APPLY_UTIL_FIELD(DATA_, EXPAND ARG_)
#define APPLY_UTIL_FIELD(...) APPLY_UTILI_FIELD(__VA_ARGS__)
#define APPLY_UTILI_FIELD( STRUCT_, FIELD_, TYPE_, CHILD_) \
   { .name = #FIELD_, .type = TYPE_, .offset = offsetof(struct STRUCT_, FIELD_), .child = EXPAND CHILD_ },

#define META_FIELD(NAME_, TYPE_) (NAME_, TYPE_, (NULL))
#define META_FIELD_SUB(NAME_, SUB_) (NAME_, mt_struct, SUB_)

演示

Showing your example

注意事项

嵌套

这些宏允许无限期嵌套 META_SUBSTRUCT 调用而不会遇到蓝色油漆,因为所有这些宏最终都会在参数替换阶段进行评估(... 参数提到 __VA_ARGS__ 会导致所有参数扩展;每个级别的META_SUBSTRUCT 是此场景中的顶级扩展;此条件重复)。

你的六个字段

鉴于您展示的示例字段少于您使用的字段,您需要专门调整用户定义的 META_FIELD、META_FIELD_SUB 等宏以生成 k-tuples 而不是 3-tuples ( k 是你需要的)。然后,只需调整 APPLY_UTILI_FIELD 的参数和扩展以匹配。

微软兼容性

此代码假定使用标准 C 预处理器。如果您正在专门研究 MSVC(没有一个),它将无法正常工作。具体来说,MSVC 未能在应有的情况下扩展 __VA_ARGS__;如果您关心在 MSVC 上工作,请将这三个对应的宏更改为:

#define COUNT(...) EXPAND(COUNT_I(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1,))
#define FIRST(...) EXPAND(FIRST_I(__VA_ARGS__,))
#define APPLY_UTIL_FIELD(...) EXPAND(APPLY_UTILI_FIELD(__VA_ARGS__))

结果也应该适用于符合标准的 CPP。

【讨论】:

  • 谢谢!它有效,而且我了解它是如何运作的,这对我来说非常重要!
猜你喜欢
  • 2012-05-27
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2013-03-14
  • 2011-05-14
相关资源
最近更新 更多