执行“#define”和内联行为相同吗？

Question

我的标题之一中有一些简短的定义，如下所示：

#define ROUND_DOWN(a,b)   (a)-(a)%(b)

例如

ROUND_DOWN(178,32) = 160

，但是如果我将其传递给它：

ROUND_DOWN(160*2, 32);

那么它会像这样编译？

(160*2)-(160*2)%(32), 

这只是更多的处理，因为它做了 160*2 两次。

我想知道内联函数的行为是否相同？例如，

inline int RoundDown(int a, int b)
{
return (a)-(a)%(b)
}

160*2 会作为 320 存储在“int a”中，然后计算会起作用，还是会与定义的行为相同？

一个更好的例子是调用：

RoundDown((x+x2)*zoom, tile_width);

Answer 1

“#define”和内联的行为相同吗？

不，它们不一样！

宏和内联函数之间存在许多差异。

- 求值次数

作为参数传递给内联函数的表达式将求值一次。

在某些情况下，作为参数传递给宏的表达式可以被多次求值。
每次在宏中使用参数时，都会对该参数进行求值。

代码示例：

#define max(a,b) (a>b?a:b)

int main()
{

  int a = 0;
  int b = 1;

  int c = max(a++, b++);

  cout << a << endl << b << endl;
  return 0;

}

本意可能是打印 1 和 2，但宏扩展为：

int c = a++ > b++ ? a++ : b++;

b 递增两次，程序打印 1 和 3。

< em>- 谁评估它们

内联函数由编译器评估，而宏由预编译器在预编译时评估。

- 类型检查

内联函数遵循对普通函数强制执行的所有类型安全协议。
检查参数类型，并正确执行必要的转换。
编译器在将内联函数放入符号表之前执行返回类型检查、函数签名。
它们可以被重载，以便对正确类型的数据执行正确类型的操作。

与内联函数相比，宏更容易出错。参数没有类型化（宏适用于算术类型的任何对象）。
编译期间不进行错误检查。

代码示例：

#define MAX(a, b) ((a < b) ? b : a)

int main( void)
{
   cout << "Maximum of 10 and 20 is " << MAX("20", "10") << endl;
   return 0;
}

可以将字符串传递给执行一些整数算术的宏，并且宏不会抱怨！

- 建议还是命令？

内联只是给编译器的建议。是否内联扩展函数由编译器决定。

宏将始终被扩展。

- 调试怎么样？

内联函数的调试很容易，因为您可以在内联函数定义处放置断点，然后单步执行到方法中进行调试。

宏不能用于调试，因为它们在预编译时扩展。

Answer 2

首先，您几乎应该假设所有常量表达式都是在编译时计算的，因此当您运行程序时，乘法永远不会被执行。

其次，您不能依赖 inline 产生任何效果，它只是对编译器的提示，而不是要求。

但即使函数不是内联的，表达式也不会被计算两次，因为参数传递要求它在函数体运行之前被计算。

Answer 3

#define 是简单的文本替换，因此（正如您所注意到的）您可能需要小心括号等。内联参数会正常解析。

存在与条件有关的相关问题。

Answer 4

名义上，函数参数 160*2 仅计算一次，然后将结果用在函数体中，而宏则计算 160*2 两次。如果参数表达式有副作用，那么你可以看到这个[*]：ROUND_DOWN(printf("hi!\n"), 1); vs RoundDown(printf("hi !\n"), 1);

实际上，无论函数内联还是宏展开，都只是表达式中的整数运算，没有副作用。优化编译器可以计算出整个宏/函数调用的结果，并将答案粘贴在发出的代码中。因此，您可能会发现您的宏和内联函数会导致执行完全相同的代码，因此 int a = ROUND_DOWN(160*2, 32); 和 int a = RoundDown( 160*2, 32); 可能都与 int a = 320; 相同。

在没有副作用的情况下，优化还可以存储和重用中间结果。因此，int c = ROUND_DONW(a*2, b);最终可能会发出看起来像您编写的代码：

int tmp = a*2;
int c = tmp - tmp % b;

请注意，是否真正内联函数是由编译器基于以下内容做出的决定 ：根据自己的优化规则。这些规则可能会考虑函数是否被标记为内联，但很可能不会，除非您使用编译器选项强制内联或其他方式。

因此，假设有一个像样的编译器，就没有理由为此使用宏 - 特别是对于您的宏，您只是乞求有人来写：

int a = ROUND_DOWN(321, 32) * 2;

然后浪费几分钟想知道为什么结果是 319。

[*]尽管不要得意忘形 - 对于某些具有副作用的表达式，例如 i++（其中 i 是整数），由于缺少序列点，宏具有未定义的行为。

Answer 5

在您给出的常量示例中，在任何合理的编译器上，两个版本都会在编译时计算常量。

假设您实际上是在询问传入变量的情况，我希望编译器的优化器在这两种情况下生成相同的代码（如果保存结果更有效，它就不会执行两次乘法。最后，内联函数确实为编译器提供了进行实际函数调用的选项（如果它可以提高性能）

最后请注意，我不会担心这样的微优化，因为 99% 它不会。影响影响程序的性能 - I/O 将成为您的瓶颈。