是否可以让一个宏对一个特定的参数值进行不同的扩展，而对所有其他参数进行不同的扩展？

假设我定义了一个当前用户:

#define CURRENT_USER john_smith

我想要做的是有一个宏，如果用户传递匹配 CURRENT_USER，它将以不同的方式扩展。请注意，我事先并不知道所有可能的用户。最基本的案例:

#define IS_CURRENT_USER(user)                   \
    /* this is not valid preprocessor macro */  \
    #if user == CURRENT_USER                    \
        1                                       \
    #else                                       \
        0                                       \
    #endif                                      

使用这样的宏，依赖用户名的所有其他宏都可以通过以下方式完成:

#define SOME_USER_SPECIFIC_MACRO(user) SOME_USER_SPECIFIC_MACRO_SWITCH_1(IS_CURRENT_USER(user))

#define SOME_USER_SPECIFIC_MACRO_SWITCH_1(switch)   SOME_USER_SPECIFIC_MACRO_SWITCH_2(switch) // expand switch ...
#define SOME_USER_SPECIFIC_MACRO_SWITCH_2(switch)   SOME_USER_SPECIFIC_MACRO_##switch         // ... and select specific case

#define SOME_USER_SPECIFIC_MACRO_0  ... // not current user
#define SOME_USER_SPECIFIC_MACRO_1  ... // current user

这可能吗？

编辑:让我澄清一下。假设每个程序员在他们的配置头中定义了不同的 CURRENT_USER。当且仅当它们的 user 参数与 CURRENT_USER 匹配时，我希望用户特定的宏扩展为有意义的东西。因为我希望这些宏包含 _pragmas，所以它不能进行运行时检查(如下面的一些回答者所建议的那样)。

编辑:再次澄清。假设有一个宏可以禁用某些代码段的优化:

#define TURN_OPTIMISATION_OFF __pragma optimize("", off)

一些程序员希望关闭不同代码段的优化，但不是一次全部关闭。我想要的是有一个宏:

#define TURN_OPTIMISATION_OFF(user) /* magic */

这将匹配 user 参数与 CURRENT_USER 宏，取自每个程序员的配置文件。如果用户匹配宏则扩展为 pragma。如果没有，那就什么都没有。

最佳答案

首先，您可以使用 ## 与预处理器进行模式匹配。这就是 IIF 宏的定义方式:

#define IIF(cond) IIF_ ## cond
#define IIF_0(t, f) f
#define IIF_1(t, f) t

但是，这种方法存在一个问题。 ## 运算符的一个微妙的副作用是它禁止扩展。举个例子:

#define A() 1
//This correctly expands to true
IIF(1)(true, false) 
// This will however expand to IIF_A()(true, false)
// This is because A() doesn't expand to 1,
// because its inhibited by the ## operator
IIF(A())(true, false) 

解决此问题的方法是使用另一种间接方式。由于这很常见，我们可以编写一个名为 CAT 的宏，它可以无限制地连接。

#define CAT(a, ...) PRIMITIVE_CAT(a, __VA_ARGS__)
#define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__

所以现在我们可以编写 IIF 宏了:

#define IIF(c) PRIMITIVE_CAT(IIF_, c)
#define IIF_0(t, ...) __VA_ARGS__
#define IIF_1(t, ...) t

#define A() 1
//This correctly expands to true
IIF(1)(true, false) 
// And this will also now correctly expand to true
IIF(A())(true, false)

通过模式匹配，我们可以定义其他操作，例如采用补码的COMPL:

// A complement operator
#define COMPL(b) PRIMITIVE_CAT(COMPL_, b)
#define COMPL_0 1
#define COMPL_1 0
// An and operator
#define BITAND(x) PRIMITIVE_CAT(BITAND_, x)
#define BITAND_0(y) 0
#define BITAND_1(y) y

接下来，可以使用检测技术来检测参数是某个值还是括号。它依赖于扩展为不同数量参数的可变参数。检测的核心是一个带有 PROBE 宏的 CHECK 宏，如下所示:

#define CHECK_N(x, n, ...) n
#define CHECK(...) CHECK_N(__VA_ARGS__, 0,)
#define PROBE(x) x, 1,

这很简单。当探针被赋予 CHECK 宏时，如下所示:

CHECK(PROBE(~)) // Expands to 1

但如果我们给它一个标记:

CHECK(xxx) // Expands to 0

因此，我们可以创建一些检测宏。例如，如果我们想检测括号:

#define IS_PAREN(x) CHECK(IS_PAREN_PROBE x)
#define IS_PAREN_PROBE(...) PROBE(~)
IS_PAREN(()) // Expands to 1
IS_PAREN(xxx) // Expands to 0

接下来，我们需要比较两个标记，我们可以依靠宏不递归扩展的事实。我们强制宏在另一个宏内部递归扩展。如果两个标记相同，那么它将递归地扩展宏，我们将通过尝试检测它们是否扩展为括号来检测，这里是 COMPARE 宏:

#define COMPARE(a, b) PRIMITIVE_COMPARE(a, b)
#define PRIMITIVE_COMPARE(a, b) \
    IIF( \
        BITAND \
            (IS_PAREN(COMPARE_ ## a(()))) \
            (IS_PAREN(COMPARE_ ## b(()))) \
    )( \
        COMPL(IS_PAREN( \
            COMPARE_ ## a( \
                COMPARE_ ## b \
            )(()) \
        )), \
        0 \
    ) \

您要比较的每个标记都可以这样定义:

// So you would define one for each user
#define COMPARE_john_smith(x) x
#define COMPARE_another_user_name(x) x

现在，我不完全理解您想要生成的最终输出，所以假设您有一个用于为当前用户和其他用户生成代码的宏:

#define MACRO_CURRENT_USER(user) ...
#define MACRO_OTHER_USER(user) ...

那么你可以这样写:

// Detects if its the current user
#define IS_CURRENT_USER(user) COMPARE(user, CURRENT_USER)
// Your macro
#define MACRO(user) IIF(IS_CURRENT_USER(user))(MACRO_CURRENT_USER, MACRO_OTHER_USER)(user)

关于c++ - 基于参数的 C 预处理器宏特化，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11632219/