（奇怪？）GCC 预处理器行为

发布于 2024-10-14 23:02:02 字数 617 浏览 1 评论 0原文

我想大多数使用过 C/C++ 的人都对预处理器的工作原理有一定的直觉（或多或少）。直到今天我也是这么认为的，但事实证明我的直觉是错误的。故事是这样的：

今天我尝试了一些东西，但我无法解释结果。首先考虑下面的代码：

#define A B
#define B A

A
B

会发生什么？好吧，使用 -E 标志编译后的结果是这样的：

A
B

好吧，也许不是任何人所期望的，但它是可以解释的。我猜想预处理器以某种方式发现存在一些问题，但什么也没做。

我尝试的下一件事是：

#define A B
#define B A C
#define C x

A
B

现在对我来说，无法解释的结果：

A x
B x

这是怎么发生的？我无法弄清楚这是如何发生的任何合理的方式。第一条命令（#define AB）无法执行，因为这样 A 就会被 B 替换，并且两者的最终结果应该相同。但如果不是的话，那么“A x”就不可能发生！

我的问题：我错过了什么？显然我不知道预处理器的确切工作方式。你知道有关它的任何消息来源吗？

原文

I guess most of you who have worked with C/C++ have an intuition of how the preprocessor works (more or less). I thought so until today, but my intuition was proved wrong. Here is the story:

Today I tried something, but I can not explain the result.
First consider the following code:

#define A B
#define B A

A
B

What happens? Well, the result after compiling it with the -E flag is this:

A
B

Well, ok, maybe not what anyone would expect, but it is explainable. I guess that the preprocessor somehow figured out that there is some problem, and did nothng.

The next thing I tried was this:

#define A B
#define B A C
#define C x

A
B

Now to the, for me, unexplainable result:

A x
B x

How did this happen? I can not figure out any reasonable way of how this happened. The first command (#define A B) can not be executed, because then A would be replaced by B, and the final result should be same for both. But if it is not, then there is no way that "A x" can happen!

My question: What am I missing? Obviously I don't know the exact way of how the preprocessor works. Do you know any sources about it?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

汐鸠 2024-10-21 23:02:02

自引用宏解释。扩展被深入应用，但一旦宏引用自身就会停止。

回复收藏 0 原文

小嗲 2024-10-21 23:02:02

#define A B
#define B A C
#define C x

A -> B -> A C -> A x 
B -> A C -> B x

扩展是“惰性地”逐个令牌进行的

#define A B
#define B A C
#define C x

A -> B -> A C -> A x 
B -> A C -> B x

Expansion is token by token "lazily"

回复收藏 0 原文

鹿港巷口少年归 2024-10-21 23:02:02

每个替换链最多可以访问任何宏定义一次。除此之外，这意味着您不能使用递归宏。

第二个示例的替换将如下所示：

A --[evaluate A]--> B --[evaluate B]--> A C --[evaluate C]--> A x
B --[evaluate B]--> A C --[evaluate A,C]--> B x

在第一行的最后一步中，不会评估 A，因为它之前已被调用。同样，在第二行中，计算在 B 处停止，因为它已在第一步中被访问过。

C99 标准的相关部分是6.10.3.4 重新扫描和进一步替换。

Each chain of substitutions can visit any macro definition at most once. Among other things, this means that you can't have recursive macros.

The substitutions for your second example will look like this:

A --[evaluate A]--> B --[evaluate B]--> A C --[evaluate C]--> A x
B --[evaluate B]--> A C --[evaluate A,C]--> B x

During the last step of the first line, A is not evaluated because it was already invoked previously. Similarly, in the second line, evaluation stops at B because it has already been visited during the first step.

The relevant section of the C99 standard would be 6.10.3.4 Rescanning and further replacement.

回复收藏 0 原文