内联函数

Question

可能重复： 内联函数在C++中的好处？

对于内联函数，我有一个困惑。

人们说，内联函数通过用原始代码替换函数来节省CPU时间，但是与普通函数相比，它增加了代码的大小。

所以真正的问题是，如果我继续在循环中调用内联函数10次，代码大小会增加吗？

假设内联函数的大小是2字节，它会增加20字节吗？

有人能给我解释一下吗？

Answer 1

相同的代码将被执行10次。但是仍然在循环中，所以代码不会在一行中复制10次。因此，规模不会随着处决次数的增加而增加。

Answer 2

我不知道为什么你会认为循环迭代的次数会很重要。让我们看看。假设您这样写：

inline int foo() { return 5 * gargle(); }

/* later... */

for (size_t i = 0; i < 100; ++i)
{
  const int x = i * foo();
  baz(x + lookup[i]);
}

如果foo被内联，那么编译器本质上将您的代码视为您已经编写的代码：

for (size_t i = 0; i < 100; ++i)
{
  baz(i * (5 * gargle()) + lookup[i]);
}

因此，代码只在调用站点被替换一次。

(循环展开是否正在发生是一个完全不同的问题。)

Answer 3

这完全取决于你、你的代码和你的编译器。想象一下你有：

#include <vector>

int frob (int a, int b) {
    return a + b;
}

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; ++i) {
        results[i] = frob(lhs[i], rhs[i]);
    }
}

现在，如果您的编译器优化了大小，它可能会保持原样。但是，如果它优化了性能，它可能(或者不可能，某些编译器使用粗略的启发式度量来确定这一点)将其转换为：

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; ++i) {
        results[i] = lhs[i] + rhs[i];
    }
}

如果它优化得更多，它可能会展开循环。

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; i+=4) {
        results[i] = lhs[i] + rhs[i];
        results[i+1] = lhs[i+1] + rhs[i+1];
        results[i+2] = lhs[i+2] + rhs[i+2];
        results[i+3] = lhs[i+3] + rhs[i+3];
    }
}

尺寸增加了。但是，如果编译器现在决定也进行一些自动矢量化，它可能会再次转换为与此类似的内容：

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; i+=4) {
        vec4_add (&results[i], &lhs[i], &rhs[i]);            
    }
}

尺寸缩小。

接下来，聪明的编译器再次展开并完全终止循环：

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);

    vec4_add (&results[i], &lhs[i], &rhs[i]);            
    vec4_add (&results[i+4], &lhs[i+4], &rhs[i+4]);
    vec4_add (&results[i+8], &lhs[i+8], &rhs[i+8]);
    vec4_add (&results[i+12], &lhs[i+12], &rhs[i+12]);
    vec4_add (&results[i+16], &lhs[i+16], &rhs[i+16]);
}

如果一个优化g++可以用一个普通数组替换一个向量，那么它就会进行优化。

int main () {
    int results[20] = {0}, lhs[20] = {0}, rhs[20] = {0};

    vec4_add (&results[i], &lhs[i], &rhs[i]);            
    vec4_add (&results[i+4], &lhs[i+4], &rhs[i+4]);
    vec4_add (&results[i+8], &lhs[i+8], &rhs[i+8]);
    vec4_add (&results[i+12], &lhs[i+12], &rhs[i+12]);
    vec4_add (&results[i+16], &lhs[i+16], &rhs[i+16]);
}

它看到一切都是恒定的，并折叠起来。

int main () {
    int results[20] = {0}; // because every lhs[0]+rhs[0] == 0
}

它得出的结论是，结果实际上是未使用的，并最终说出：

int main() {
}