“ Lambda很便宜”-真的吗？什么情况下

如何解决“ Lambda很便宜”-真的吗？什么情况下

本文声明使用C ++ Lambdas是“便宜的”： Lambdas aren't magic - part 2

它们演示了如何将lambda传递给现有的std函数/模板。 一篇文章演示了如何在不使用std :: function的情况下使用“自动”作为函数的返回类型来返回lambda。

我没有看到任何文章演示如何实现自己的功能，尤其是。类成员函数，该函数需要使用lambda或更多的值，而无需使用std :: function。

因此，这种大胆的“ lambda很便宜”的声明-在现实世界中是真的吗？

作为参考：“便宜”在我进行此特定任务时是要解决的：在具有几百千字节内存和两位数MHz速度的嵌入式裸机项目上合理使用。 （我一直在该领域中使用C ++的合理子集，并在寻找我还可以使用的东西）

从我看到的结果来看，std :: function 并不便宜。作为一个std :: function传递的Lambdas显然无法再进行内联优化了。 但更糟糕的是，std :: function 为32个字节。 同样很明显，如果捕获了不止一个，将使用动态分配吗？ 听起来一切都是坏消息。

因此，当我在寻找不带std :: function的lambda的方法时，仅发现一个返回auto的示例，我尝试了以下操作： 我已经做了一个非常简单的类，它在成员函数中的参数类型中使用了“自动”，并且编译器似乎对此很满意（尽管就预期的函子参数而言，它不像std :: function那样是“自我记录”代码）。

struct FuncyClass
{   unsigned func(auto fnx)
    {   return 2 * fnx(7);
    }
};

int main()
{   FuncyClass fc;
    auto result = fc.func( [](auto x){return x*3;} );
    
    printf("Result: %u\n",result);
    return 0;
}
// Output: "Result: 42"

但是我有一个感觉，这个非常简单的场景并没有显示出当更复杂的场景使用它时可能出现的编译器错误泛滥。 我不了解这种语法在后台发生了什么，编译器在根据函子的使用来确定时需要做什么，需要使用什么参数和返回类型，以及如何在后台实现带有自动参数的功能

那（即使用自动类型的args）真的是使类成员函数可以lambda自定义的明智方法吗？ 然后看起来“便宜”，因为在我的测试中，当使用auto而不是std :: function时，可执行文件要小得多。

当然，它仍然是受限制的： 如果没有使用std :: function （或类似类型的DIY包装器），则类无法保持lambda，对吗？ 是否有可能防止动态分配的发生，例如在出现需要std :: function分配内存的方案时，是否使其成为编译时错误？

解决方法

Lambda只是使operator()重载的对象。您可以从概念上将它们视为等同于：

class Lamba {
public:
    auto operator()(...) const { /* ... */ }
};

因此，它们并不比类似的函数调用昂贵。 std::function不需要使用lambda。您可以使用类型推断来存储/传递它们：

template <typename Func>
void foo(Func&& func) { /* ... */ }

对于非捕获的lambda，您可以使用operator+隐式或显式地将它们转换为函数指针：

void (*fp)(int) = [](int){ /* ... */ };

之所以难以回答您的问题，是因为您要问lambda是否昂贵。但是，与什么相比呢？如果您想知道他们是否在您的特定情况下有足够的表现，则需要为自己做一些分析，并弄清楚。

,

std::function很好，因为它语法简单（比函数指针容易得多），并且可以自我记录所需的函数类型（与模板相比，需要显式文档）。我想有关lambda的介绍性文章会用到它，因为要等到您有一定的限制之后才能看到成本。

还有两种方法可以接受lambda作为参数：函数指针和模板。

未捕获的lambda可以隐式转换为函数指针：

struct FuncyClass
{   unsigned func(int(*fnx)(int)) 
    {   return 2 * fnx(7);
    }
};

int main()
{   FuncyClass fc;
    auto result = fc.func( [](auto x){return x*3;} );
    
    printf("Result: %u\n",result);
    return 0;
}

捕获和不捕获lambda可以借助模板来传递：

struct FuncyClass
{   
    template<typename Func>
    unsigned func(Func&& fnx)
    {   return 2 * fnx(7);
    }
};

int main()
{   FuncyClass fc;
    int multiplier = 3;
    auto result = fc.func( [multiplier](auto x){return x*multiplier;} );
    
    printf("Result: %u\n",result);
    return 0;
}

,

“ Lambda很便宜”

这是一个相对的概念。

实际上，这很大程度上取决于您的C ++编译器。

尝试使用最新的GCC（在2020年，使用GCC 10）和enable警告和优化，因此在命令行上使用{{1 }}。

然后进行基准测试或profile您的应用程序

在Linux上，请参见time(7)并考虑使用gprof(1)或perf(1)（当然，一旦使用GDB调试了程序）。对于其他操作系统和编译器，请找到等效的版本。

此draft报告可能会建议您optimizations是一个好的编译器可以做什么（有时由于Rice's theorem而不能做到）。有时 会发生lambda应用程序变为inlined。

如果您喜欢functional programming范例，请考虑也使用Ocaml，Common Lisp（SBCL）或Haskell。您会发现在实际情况中 可能比C ++更快（使用GCC或Clang），特别是在Linux上用于单线程程序的情况。

根据经验，我倾向于认为C ++ lambda只要它的主体正在执行某些重要工作（例如在某些C++ container中进行迭代（或搜索）），便会很便宜。如果lambda主体只是进行整数加法运算，则开销会很大（除非编译器足够聪明以内联它）。如果它在具有成千上万个条目的g++ -Wall -Wextra -O2上执行find operation，或者实际上使用动态分配（因此某些std::map，经常使用new ）通常并不重要。

实际上，从YMMV开始，您需要分析您的应用程序。