模板 lambda 与带有模板运算符（）的仿函数

Question

受this question 的启发，我想将c++20 模板lambda 的使用与具有模板operator() 的函子进行比较。

作为一个测试用例，考虑一个模板函数call，它接受一个模板 lambda 作为参数，并调用这个 lambda 并使用一些模板参数对其进行实例化。下面的c++20 代码就是这个想法的例证。

#include <tuple>
#include <utility>

template <int I, class Lambda, class... ArgsType>
void call(Lambda&& F, ArgsType&& ...args)
{
           F.template operator()<I>(std::forward<ArgsType>(args)...);
}

int main() {
   std::tuple<int, double, int> t{0,0,0};
   int a = 2;

   auto f = [&]<int I>(auto& x) { std::get<I>(x) += I + a; };
   call<0>(f, t);

   return 0;
}

在c++11/c++14/c++17 中，没有模板 lambda，可以使用具有模板 operator() 的函子来实现相同的任务，如下面的代码所示。

#include <tuple>
#include <utility>

template <int I, class Lambda, class... ArgsType>
void call(Lambda&& F, ArgsType&& ...args)
{
           F.template operator()<I>(std::forward<ArgsType>(args)...);
}

struct Functor {
    template <int I, class T>
    void operator()(const int& a, T& x) { std::get<I>(x) += I + a; };
};

int main() {
   std::tuple<int, double, int> t{0,0,0};
   int a = 2;

   Functor func{};
   call<0>(func, a, t);

}

我在第二个示例中看到的主要缺点是，为了模拟 lambda 捕获，需要将所有局部变量（在本例中为 int a）显式传递给函子。如果Functor::operator() 需要来自其“所有者”的许多变量，这可能会很乏味。最终，也可以将指针this 传递给Functor::operator()。 c++20 示例中不存在此类复杂情况，其中 lambda 捕获负责捕获所需的变量。

除了简单之外，上述两种方法之间还有其他具体区别吗？效率怎么样？

Answer 1

我在第二个示例中看到的主要缺点是，为了模拟 lambda 捕获，需要将所有局部变量（在本例中为 int a）显式传递给函子。

我不同意。

您几乎可以将 lambda 视为具有 operator() 的类/结构以及与捕获的变量相对应的一些成员。

所以不是

[&]<int I>(auto& x) { std::get<I>(x) += I + a; };

你可以写（已经从 C++11 开始）

struct nal // not a lambda
 {
   int const & a;

   template <int I, typename T>
   auto operator() (T & x) const
    { std::get<I>(x) += I + a; }
 };

按如下方式使用

call<0>(nal{a}, t);

我看到函子的主要缺点（我认为这是一个缺点值得怀疑）是你不能简单地通过引用或值（[&] 或 [=]）捕获所有外部变量，但你在定义仿函数和初始化仿函数对象时，必须明确列出您使用的所有变量。

题外话：注意我在nal 结构中标记了const operator()。

如果不修改捕获的变量，则 lambda 等效于具有常量 operator() 的函子。

如果您将仿函数作为常量引用传递，这一点很重要

template <int I, class Lambda, class... ArgsType>
void call (Lambda const & F, ArgsType&& ...args)
{ // ......^^^^^^^^^^^^^^  now F is a constant reference
  F.template operator()<I>(std::forward<ArgsType>(args)...); // compilation error
                                                             // if operator()
                                                             // isn't const
} 

如果operator() 不是const，则会出现编译错误