主页 / 问题 / 1306776
Accepted
Anton Shchyrov
Asked:2022-07-19 23:20:41 +0800 CST2022-07-19 23:20:41 +0800 CST

宏扩展为字符串

  • 772

这里描述了如何组织文件版本的自动增量。

特别是有这样的线路

#define VERSION_MAJOR 1
#define VERSION_MINOR 0
#define VERSION_PATCH 0
#define VERSION_BUILD 0

#define stringify(a) stringify_(a)
#define stringify_(a) #a

然后使用

VALUE "FileVersion", stringify(VERSION_MAJOR) "." stringify(VERSION_MINOR) "." stringify(VERSION_PATCH) "." stringify(VERSION_BUILD)

一切正常，但我不明白如何。宏在这里是如何工作的stringify？

如果你这样声明

#define stringify(a) #a

然后将该行写入 FileVersionVERSION_MAJOR.VERSION_MINOR.VERSION_PATCH.VERSION_BUILD

这是一种什么样的构造#a，为什么要嵌套在另一个宏中？

c

2 个回答

  1. 字符串化解释说它#a把它的参数变成了一个字符串。但是有一个特点：

    与普通参数替换不同，参数不是首先进行宏扩展的。这称为字符串化。

    在转换为字符串之前，不会评估参数。这导致stringify_(VALUE)在"VALUE".

    如果展开stringify(VALUE)，则在将其传递给嵌套宏之前，参数将展开并获取stringify_(1)，然后将展开为"1".

    双重嵌套导致预处理器在字符串化之前评估值。

    自己试试：

    #define VALUE 1234
#define stringify(a) stringify_(a)
#define stringify_(a) #a

#include <stdio.h>

int main() {
    puts(stringify_(VALUE));
    puts(stringify(VALUE));
}

    $ gcc stringify.c && ./a.out 
VALUE
1234

    您可能想知道为什么预处理器在任何地方都计算参数，而不是在字符串化期间？要使这样的事情起作用：

    #include <stdio.h>

#define DUMP(expr) printf("%s = %d\n", #expr, (expr))
#define VALUE 42

int main() {
    int a = 2;
    int b = 3;
    DUMP(a + b);
    DUMP(VALUE);
    DUMP(a + b + VALUE);
}

    $ gcc stringify.c && ./a.out 
a + b = 5
VALUE = 42
a + b + VALUE = 47
    • 5
  2. Best Answer

    #a是一个预处理器构造（这很重要，因为它在法律上在编译器之前工作），这意味着一件事 - 替换#a为"a".

    当你写

    #define stringify(a) #a
VERSION_MAJOR(VERSION)

    然后预处理器就是这样做的——它只是替换它，结果是"VERSION"。

    当使用第一个正确的方法时，在第一次迭代中它会像这样显示

    stringify(VERSION_MAJOR) "."

    变成

    stringify_(1) "."

    并且预处理器检测到仍然存在宏并进行第二次迭代

    "1" "."

    然后将这些线条粘在

    "1."
    • 3

相关问题