为什么在宏中使用明显无意义的 do-while 和 if-else 语句？

Question

在许多 C/C++ 宏中，我看到宏的代码包裹在看似无意义的 do while 循环中。以下是示例。

#define FOO(X) do { f(X); g(X); } while (0)
#define FOO(X) if (1) { f(X); g(X); } else

我看不到 do while 正在做什么。为什么不直接写这个呢？

#define FOO(X) f(X); g(X)

Answer 1

do ... while 和 if ... else 的作用是让
宏后面的分号总是表示相同的意思。就说你吧
有类似你的第二个宏的东西。

#define BAR(X) f(x); g(x)

现在，如果您要在 if ... else 语句中使用 BAR(X);，其中 if 语句的主体未包含在大括号中，那么您'会得到一个糟糕的惊喜。

if (corge)
  BAR(corge);
else
  gralt();

上面的代码将扩展为在

if (corge)
  f(corge); g(corge);
else
  gralt();

语法上不正确的which，因为else不再与if相关联。在宏中将内容括在大括号中没有帮助，因为大括号后面的分号在语法上是不正确的。

if (corge)
  {f(corge); g(corge);};
else
  gralt();

有两种方法可以解决该问题。第一种是使用逗号对宏内的语句进行排序，而不剥夺其像表达式一样的功能。

#define BAR(X) f(X), g(X)

上面版本的 bar BAR 将上面的代码扩展为下面的代码，这在语法上是正确的。

if (corge)
  f(corge), g(corge);
else
  gralt();

如果您有更复杂的代码体，需要放入自己的块中（例如声明局部变量），而不是 f(X)，则此方法不起作用。在最常见的情况下，解决方案是使用诸如 do ... while 之类的内容来使宏成为带有分号的单个语句，而不会造成混淆。

#define BAR(X) do { \
  int i = f(X); \
  if (i > 4) g(i); \
} while (0)

您不必使用 do ... while，您也可以使用 if ... else 来编写一些东西，尽管当 if ... else 在 if ... else 内部展开，它会导致“dangling else”，这可能会使现有的 dangling else 问题更难找到，如以下代码所示。

if (corge)
  if (1) { f(corge); g(corge); } else;
else
  gralt();

要点是在悬空分号错误的情况下用完分号。当然，此时可能（并且可能应该）争论将 BAR 声明为实际函数而不是宏会更好。

总之，do ... while 的作用是解决 C 预处理器的缺点。当那些 C 风格指南告诉您放弃 C 预处理器时，他们担心的是这种事情。

Answer 2

宏是预处理器将复制/粘贴的文本片段放入真正的代码中；该宏的作者希望替换后能够生成有效的代码。

要成功做到这一点，有三个很好的“技巧”：

帮助宏像真正的代码一样运行

普通代码通常以分号结尾。如果用户查看不需要分号的代码...

doSomething(1) ;
DO_SOMETHING_ELSE(2)  // <== Hey? What's this?
doSomethingElseAgain(3) ;

这意味着用户希望编译器在不存在分号的情况下产生错误。

但真正好的理由是，在某些时候，宏的作者可能需要用真正的函数（可能是内联的）替换宏。因此，宏应该真正表现得像一个宏。

所以我们应该有一个需要分号的宏。

生成有效代码

正如 jfm3 的答案所示，有时宏包含多个指令。如果在 if 语句中使用该宏，则会出现问题：

if(bIsOk)
   MY_MACRO(42) ;

该宏可以扩展为：

#define MY_MACRO(x) f(x) ; g(x)

if(bIsOk)
   f(42) ; g(42) ; // was MY_MACRO(42) ;

无论 bIsOk 的值如何，都会执行 g 函数。

这意味着我们必须向宏添加一个作用域：

#define MY_MACRO(x) { f(x) ; g(x) ; }

if(bIsOk)
   { f(42) ; g(42) ; } ; // was MY_MACRO(42) ;

生成有效的代码 2

如果宏类似于：

#define MY_MACRO(x) int i = x + 1 ; f(i) ;

我们在以下代码中可能会遇到另一个问题：

void doSomething()
{
    int i = 25 ;
    MY_MACRO(32) ;
}

因为它会扩展为：

void doSomething()
{
    int i = 25 ;
    int i = 32 + 1 ; f(i) ; ; // was MY_MACRO(32) ;
}

此代码将无法编译，课程。因此，解决方案再次使用范围：

#define MY_MACRO(x) { int i = x + 1 ; f(i) ; }

void doSomething()
{
    int i = 25 ;
    { int i = 32 + 1 ; f(i) ; } ; // was MY_MACRO(32) ;
}

代码再次正常运行。

结合分号+作用域效果？

有一种 C/C++ 习惯用法可以产生这种效果： do/while 循环：

do
{
    // code
}
while(false) ;

do/while 可以创建一个作用域，从而封装宏的代码，并且最后需要一个分号，从而扩展到需要分号的代码。

奖金？

C++ 编译器将优化 do/while 循环，因为在编译时就知道其后置条件为 false。这意味着像这样的宏

#define MY_MACRO(x)                                  \
do                                                   \
{                                                    \
    const int i = x + 1 ;                            \
    f(i) ; g(i) ;                                    \
}                                                    \
while(false)

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
      MY_MACRO(42) ;

   // Etc.
}

将正确扩展为

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
      do
      {
         const int i = 42 + 1 ; // was MY_MACRO(42) ;
         f(i) ; g(i) ;
      }
      while(false) ;

   // Etc.
}

，然后被编译和优化为

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
   {
      f(43) ; g(43) ;
   }

   // Etc.
}

Answer 3

@jfm3 - 你对这个问题有一个很好的答案。您可能还想补充一点，宏习惯用法还可以通过简单的“if”语句来防止可能更危险（因为没有错误）的意外行为：

#define FOO(x)  f(x); g(x)

if (test) FOO( baz);

扩展为：

if (test) f(baz); g(baz);

这在语法上是正确的，因此不会出现编译器错误，但可能会产生意外的后果g() 总是会被调用。

Answer 4

上面的答案解释了这些结构的含义，但是两者之间存在未提及的显着差异。事实上，我们有理由更喜欢 do ... while 而不是 if ... else 结构。

if ... else 构造的问题是它不会强制您输入分号。就像这段代码一样：

FOO(1)
printf("abc");

虽然我们漏掉了分号（错误地），但代码将扩展为

if (1) { f(X); g(X); } else
printf("abc");

并将静默编译（尽管某些编译器可能会对无法访问的代码发出警告）。但是 printf 语句永远不会被执行。

do ... while 构造不存在这样的问题，因为 while(0) 之后的唯一有效标记是分号。

Answer 5

说明

do {} while (0) 和 if (1) {} else 是为了确保宏仅扩展为 1 条指令。否则：

if (something)
    FOO(X); 

将扩展为：

if (something)
    f(X); g(X); 

并且 g(X) 将在 if 控制语句之外执行。使用 do {} while (0) 和 if (1) {} else 时可以避免这种情况。

---

使用

GNU 语句表达式< /a> （不是标准 C 的一部分），您有比 do {} while (0) 和 if (1) {} else 更好的方法来解决这个问题，只需使用 ({})：

#define FOO(X) ({f(X); g(X);})

并且此语法与返回值兼容（请注意 do {} while (0) 不兼容），如下所示：

return FOO("X");

Answer 6

虽然预计编译器会优化 do { ... } while(false); 循环，但还有另一种解决方案不需要该构造。解决方案是使用逗号运算符：

#define FOO(X) (f(X),g(X))

或者更奇特的是：

#define FOO(X) g((f(X),(X)))

这对于单独的指令可以很好地工作，但它不适用于构造变量并将其用作 #define 的一部分的情况：

#define FOO(X) (int s=5,f((X)+s),g((X)+s))

虽然 这将被迫使用 do/while 结构。

Answer 7

Jens Gustedt 的 P99 预处理器库（是的，这样的东西的存在也让我大吃一惊！ ) 通过定义以下内容，以小而重要的方式改进了 if(1) { ... } else 构造：

#define P99_NOP ((void)0)
#define P99_PREFER(...) if (1) { __VA_ARGS__ } else
#define P99_BLOCK(...) P99_PREFER(__VA_ARGS__) P99_NOP

其基本原理是，与 do { ... while(0) 构造，break 和 continue 仍然在给定块内工作，但是 ((void)0)如果宏调用后省略分号，则会产生语法错误，否则会跳过下一个块。 （这里实际上不存在“悬空 else”问题，因为 else 绑定到最近的 if，即宏中的那个。）

如果您感兴趣对于可以使用 C 预处理器或多或少安全地完成的各种事情，请查看该库。

Answer 8

由于某些原因，我无法对第一个答案发表评论...

你们中的一些人展示了带有局部变量的宏，但没有人提到您不能在宏中使用任何名称！总有一天它会咬住用户！为什么？因为输入参数被替换到您的宏模板中。在您的宏示例中，您使用了可能最常用的变量名称i。

例如，当在

#define FOO(X) do { int i; for (i = 0; i < (X); ++i) do_something(i); } while (0)

以下函数中使用

void some_func(void) {
    int i;
    for (i = 0; i < 10; ++i)
        FOO(i);
}

以下宏时，宏将不会使用在 some_func 开头声明的预期变量 i，而是使用在宏的 do ... while 循环中声明的局部变量。

因此，切勿在宏中使用通用变量名！

Answer 9

我不认为它被提及，所以考虑这

while(i<100)
  FOO(i++);

将被转换为

while(i<100)
  do { f(i++); g(i++); } while (0)

注意 i++ 是如何被宏计算两次的。这可能会导致一些有趣的错误。