Question

假设我的代码如下所示：

#ifdef COND1
    extern int func1(void);
#endif
...
#ifdef CONDN
    extern int funcn(void);
#endif

my_struct funcs[] = {
#ifdef COND1
    {"func1 description", func1},
#endif
...
#ifdef CONDN
    {"funcn description", funcn},
#endif
    {NULL, NULL},
};

是否可以将其替换为X macros，以最大限度地减少两个部分中函数名称和条件的重复？

如果没有#ifdef CONDX条件，这似乎非常简单。但是，我不知道如何将它们包含在X宏中，因为不允许在#ifdef中使用#define。

Answer 1

不确定 X宏是否是此处的解决方案。但是，您可以使用一些预处理器魔法来减少输入。问题仍然是您的示例中的条件编译（#ifdef s）。在不知道这些条件是什么样的情况下，很难进一步减少打字量。

Condider以下内容：

#define D(n) extern int func ## n(void);
#define A(n) {"func" #n " description", func ## n},

#ifdef COND1
  D(1)
#endif
#ifdef COND2
  D(2)
#endif

my_struct funcs[] = {
#ifdef COND1
  A(1)
#endif
#ifdef COND2
  A(2)
#endif
};

我认为这是朝着你的目标前进的一步。要了解它的作用，您可以尝试

gcc -E -DCOND1 <file-with-contents-above>.c

（如果你在某些Unix上）或

cl -E -DCOND1 <file-with-contents-above>.c

（如果您在使用Visual Studio的Windows上）。

Answer 2

假设您要定义COND1但不定义CONDN。我想你可以做到以下几点：

#define COND1(...) __VA_ARGS__
#define CONDN(...)

#define MY_XLIST \
    X(COND1, func1, "func1 description") \
    X(CONDN, funcn, "funcn description")

#define X(a, b, c) a(extern int b (void);)
MY_XLIST
#undef X

#define X(a, b, c) a({c, b},)
my_struct funcs[] = {
    MY_XLIST
    {NULL, NULL},
};
#undef X

问题在于您需要定义所有宏，但具有不同的扩展。

Answer 3

您无法在#ifdef内使用#define，因此您无法使用基于#define的X-macros，但您仍然可以使用基于#include的X-macros

例如，使用文件t.def：

#ifdef COND1
F(func1, "func1 description")
#endif
#ifdef COND2
F(func2, "func2 description")
#endif

在您的主档案中：

#define COND2

#define F(name, desc) extern int name(void);
#include "t.def"
#undef F

mystruct funcs[] = {
    #define F(name, desc) {desc, name},
    #include "t.def"
    #undef F
    {NULL, NULL},
};

这将被处理为：

extern int func2(void);

mystruct funcs[] = {
    {"func2 description", func2},
    {NULL, NULL},
};

Answer 4

我认为关键在于＆＃34;分解＆＃34;条件。例如，COND1（或COND2等）应围绕funcs数组的定义，反之亦然。在这里，我假设您可以将条件归结为整数定义。这可以做到，例如由

#if COND1
#   define N 1
#elif COND2
#   define N 2
// ...
#endif

我们还假设您有几个功能存根（不仅func），它们都扩展为stub<n> - 就像名称一样。然后，您可以完全参数化您的函数名称生成，如下所示。（代码使用字符串文字串联和 for loop 变量。gcc -std=c99编译好。）

主文件。声明函数并定义描述struct数组。

#include<stdio.h>

// example struct definition
typedef struct { const char* description; int (*f)(void); } my_struct;

// A two-stage macro expansion is necessary because
// macro parameters are taken literally when used in 
// concatenation or stringification 
// (cf. https://gcc.gnu.org/onlinedocs/cpp/Argument-Prescan.html)

// Expands to function declaration
#define X_LITERAL_PARAMS(fname, suffix) extern int fname ## suffix (void);
#define X(fname, suffix) X_LITERAL_PARAMS(fname, suffix) // this expands suffix e.g. to 1 

// define extern int functions
#define N 1 // select which function variants
#include "xmacro_x.h"   

#undef X_LITERAL_PARAMS
#define X_LITERAL_PARAMS(fname, suffix) { "Calling " #fname #suffix, fname ## suffix},

my_struct funcs[] = {
#undef N
#define N 1 // select which function variants
#include "xmacro_x.h"   
//  defines descriptions for functions
#   include "xmacro_x.h"    

};

// Print description and call each function 
// in the struct array 
int main(void)
{
    for(int i=0; i<sizeof(funcs)/sizeof(my_struct); i++)
    {
        printf("%s yields %d\n\n", funcs[i].description, funcs[i].f());
    }

    return 0;
}

文件funcs.c实际上定义了函数。

// Define functions named as in the struct array
// for proof of concept

#include <stdio.h>

// two-stage expansion again 
#define  X_LITERAL_PARAMS(f, n) \
    int f ## n (void){ return printf("This is %s\n", #f #n);}

#define X(a,b) X_LITERAL_PARAMS(a,b)

#define N 1
#include "xmacro_x.h"

最后，相当无趣的文件xmacro_x.h提供了＆＃34; X宏＆＃34;扩展到源文件中的不同代码片段。这里介绍各种＆＃34;函数系列＆＃34;，名称存根，稍后将与数字后缀组合。

// The "X macros" which will be expanded to different things later
X(func, N)
X(gunc, N)
//...

Answer 5

使用带有x宏的条件编译（我称之为列表宏）的关键是要理解预处理器指令不能包含在宏中，但是列表宏可以从较小的列表拼凑在一起。然后，较小列表的输出可以是有条件的。

解决方案是在下面代码的开头，但我已经添加了列表宏的输出以保证完整性。另请注意，较小的列表是一个项目的列表，但它们可以很容易地包含多个项目。

//Inner macro parameter list.
//FUNC_(enumTag, function, description)

//Conditional sublist.
#ifdef COND1
#define COND1_FUNC_LIST \
    FUNC_(FuncCOND_1, func1, “func1 description”)
#else
#define COND1_FUNC_LIST
#endif

//Conditional sublist.
#ifdef CONDN
#define CONDN_FUNC_LIST \
    FUNC_(FuncCOND_N, funcn, “funcn description”)
#else
#define CONDN_FUNC_LIST
#endif

//Complete list.
#define FUNC_LIST \
    COND1_FUNC_LIST \
    CONDN_FUNC_LIST \
//Comment to terminate preprocessor continuation.


//The rest generates all of the code artifacts.
#define CONDN_FUNC_ENUM(enumTag, function, description) enumTag,
#define CONDN_FUNC_EXTERN(enumTag, function, description) extern int function(void);
#define CONDN_FUNC_INITIALIZER(enumTag, function, description) {function, description},

typedef int (*FuncPtr)(void);
typedef struct
{
    FuncPtr function;
    char * description;
} FuncStruct;

enum
{
    FUNC_LIST(CONDN_FUNC_ENUM)
    FuncCOUNT
};

FUNC_LIST(CONDN_FUNC_EXTERN)

FuncStruct funcs[FuncCOUNT] = 
{
    FUNC_LIST(CONDN_FUNC_INITIALIZER)
};

将C X宏与#ifdef结合使用

5 个答案: