C ++预处理器元编程图灵完备吗？

Question

我知道C ++模板元编程是Turing-complete。 预处理器元编程是否同样适用？

Answer 1

好的宏不会直接递归扩展，但我们有办法解决这个问题。

在预处理器中进行递归的最简单方法是使用延迟表达式。 延迟表达式是需要更多扫描才能完全展开的表达式：

#define EMPTY()
#define DEFER(id) id EMPTY()
#define OBSTRUCT(...) __VA_ARGS__ DEFER(EMPTY)()
#define EXPAND(...) __VA_ARGS__

#define A() 123
A() // Expands to 123
DEFER(A)() // Expands to A () because it requires one more scan to fully expand
EXPAND(DEFER(A)()) // Expands to 123, because the EXPAND macro forces another scan

为什么这很重要？ 当扫描并扩展宏时，它会创建一个禁用上下文。 此禁用上下文将导致引用当前展开的宏的标记被涂成蓝色。 因此，一旦它涂成蓝色，宏将不再膨胀。 这就是宏不递归扩展的原因。 但是，禁用上下文仅在一次扫描期间存在，因此通过推迟扩展，我们可以防止我们的宏变为蓝色。 我们只需要对表达式应用更多扫描。 我们可以使用这个EVAL宏来做到这一点：

#define EVAL(...)  EVAL1(EVAL1(EVAL1(__VA_ARGS__)))
#define EVAL1(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__)))
#define EVAL2(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__)))
#define EVAL3(...) EVAL4(EVAL4(EVAL4(__VA_ARGS__)))
#define EVAL4(...) EVAL5(EVAL5(EVAL5(__VA_ARGS__)))
#define EVAL5(...) __VA_ARGS__

现在，如果我们想使用递归实现REPEAT宏，首先我们需要一些递增和递减运算符来处理状态：

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

#define INC(x) PRIMITIVE_CAT(INC_, x)
#define INC_0 1
#define INC_1 2
#define INC_2 3
#define INC_3 4
#define INC_4 5
#define INC_5 6
#define INC_6 7
#define INC_7 8
#define INC_8 9
#define INC_9 9

#define DEC(x) PRIMITIVE_CAT(DEC_, x)
#define DEC_0 0
#define DEC_1 0
#define DEC_2 1
#define DEC_3 2
#define DEC_4 3
#define DEC_5 4
#define DEC_6 5
#define DEC_7 6
#define DEC_8 7
#define DEC_9 8

接下来我们需要更多的宏来做逻辑：

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

#define NOT(x) CHECK(PRIMITIVE_CAT(NOT_, x))
#define NOT_0 ~, 1,

#define COMPL(b) PRIMITIVE_CAT(COMPL_, b)
#define COMPL_0 1
#define COMPL_1 0

#define BOOL(x) COMPL(NOT(x))

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

#define IF(c) IIF(BOOL(c))

#define EAT(...)
#define EXPAND(...) __VA_ARGS__
#define WHEN(c) IF(c)(EXPAND, EAT)

现在有了所有这些宏，我们就可以编写一个递归的REPEAT宏。 我们使用REPEAT_INDIRECT宏以递归方式返回自身。 这可以防止宏被涂成蓝色，因为它将在不同的扫描上展开（并使用不同的禁用上下文）。 我们在这里使用OBSTRUCT ，这将推迟两次扩展。 这是必要的，因为条件WHEN已经应用了一次扫描。

#define REPEAT(count, macro, ...) \
    WHEN(count) \
    ( \
        OBSTRUCT(REPEAT_INDIRECT) () \
        ( \
            DEC(count), macro, __VA_ARGS__ \
        ) \
        OBSTRUCT(macro) \
        ( \
            DEC(count), __VA_ARGS__ \
        ) \
    )
#define REPEAT_INDIRECT() REPEAT

//An example of using this macro
#define M(i, _) i
EVAL(REPEAT(8, M, ~)) // 0 1 2 3 4 5 6 7

由于计数器的限制，此示例限于10次重复。 就像计算机中的重复计数器一样会受到有限内存的限制。 可以将多个重复计数器组合在一起以解决此限制，就像在计算机中一样。 此外，我们可以定义一个FOREVER宏：

#define FOREVER() \
    ? \
    DEFER(FOREVER_INDIRECT) () ()
#define FOREVER_INDIRECT() FOREVER
// Outputs question marks forever
EVAL(FOREVER())

这会尝试输出? 永远，但最终将停止，因为没有更多的扫描应用。 现在问题是，如果我们给它一个无限次的扫描，这个算法会完成吗？ 这被称为暂停问题，图灵完整性是证明停止问题不可判定性所必需的。 正如您所看到的，预处理器可以充当图灵完整语言，但不是局限于计算机的有限内存，而是受限于应用的有限数量的扫描。

Answer 2

不可以.C ++预处理器不允许无限状态。 您只有有限数量的开/关状态，加上包含堆栈。 这使它成为一个下推式自动机，而不是图灵机（这也忽略了预处理器递归受限的事实 - 但模板递归也是如此）。

但是，如果稍微改变定义，可以通过多次调用预处理器来实现 - 通过允许预处理器生成重新调用预处理器的程序，并在外部循环， 确实可以使用预处理器 。 链接的示例使用C，但它应该足够容易适应C ++。