Question

我的问题是对此进行扩展：Why can lambdas be better optimized by the compiler than plain functions?

重申一下，结论是，lambda创建了不同的专业化条件，编译器可以轻松地内联，而函数指针却不那么容易内联，因为一组函数原型只有一个专业化条件。考虑到这一点，函数指针模板会像lambda一样快吗？

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

template <class F>
int operate(int a, int b, F func)
{
    return func(a, b);
}

template <int func(int, int)>
int operateFuncTemplate(int a, int b)
{
    return func(a, b);
}

int main()
{
    // hard to inline (can't determine statically if operate's f is add or sub since its just a function pointer)
    auto addWithFuncP = operate(1, 2, add);
    auto subWithFuncP = operate(1, 2, sub);

    // easy to inline (lambdas are unique so 2 specializations made, each easy to inline)
    auto addWithLamda = operate(1, 2, [](int a, int b) { return a + b; });
    auto subWithLamda = operate(1, 2, [](int a, int b) { return a - b; });

    // also easy to inline? specialization means there are 2 made, instead of just 1 function definition with indirection?
    auto addWithFuncT = operateFuncTemplate<add>(1, 2);
    auto subWithFuncT = operateFuncTemplate<sub>(1, 2);
}

因此，如果我可以按照绩效等级对其进行排名，那么：

operatorFuncTemplate> = operate<LAMBDA>> = operate<FUNCTIONPTR>

在非平凡的例子中是否存在这种关系失败的情况？

Answer 1

如果编译器可以跟踪“此函数指针指向该函数”，则编译器可以通过函数指针内联该调用。

有时候编译器可以做到这一点。有时他们不能。

除非将lambda存储在函数指针std::function或类似的类型擦除包装器中，否则在调用lambda时，编译器会知道lambda的类型，因此会知道lambda的主体。编译器可以轻松地内联函数调用。

使用函数模板没有任何改变，除非参数像函数非类型模板参数一样为constexpr：

template <int func(int, int)>

这是一个例子。这里，保证了函数主体中的函数模板在编译时是已知的。

不过，将该func传递到其他任何地方，编译器可能会丢失它。

在任何情况下，任何速度差异都将高度依赖于上下文。有时，由内联Lambda引起的较大的二进制大小会比无法内联函数指针的情况导致更慢的速度，因此性能可能会反过来。

您尝试做出的任何通用声明有时都会出错。

C ++ 11性能：Lambda内联与函数模板专业化

1 个答案: