第三章 Lambda in C++14

预计阅读时间15 分钟 38 views

相较于 C++11， C++14 对 Lambda 表达式进行了两项重要的增强：

带初始化器的捕获
泛型 Lambda

此外，标准还更新了一些规则以解决 C++11 中存在的问题，例如：

Lambda 默认参数
返回类型为 auto

Lambda 表达式的默认参数

在 C++14 中， Lambda 表达式可以使用默认参数，这一小特性使得 Lambda 表达式更像普通函数：

#include <iostream>

int main(){
    const auto lam = [](int x = 10){ std::cout << x << '\n'; }
    lam();
    lam(100);
}
/* output:
 * 10
 * 100
 */

C++

返回类型(Return Type)

在 C++14 中，返回类型的推导功能得到了改进和扩展，使得 Lambda 表达式和普通函数都可以使用'auto'作为返回类型：

auto myFunction(){
    int x = computeX(...);
    int y = computeY(...);
    return x + y;
}

C++

在上面的例子中，编译器会推导出'int'作为返回类型。

Lambda 表达式遵循和使用'auto'返回类型的函数相同的规则：

auto foo = [](int x){
    if(x < 0) return x * 1.1f;  // return type -> float
    else return x * 2.1;        // return type -> double
}

C++

上面的代码段无法通过编译，因为第一个返回语句返回'float'，而第二个返回语句返回‘double'，编译器无法确定统一的返回类型，因此需要确保所有返回语句推导出相同的类型。

返回 Lambda 表达式

#include <iostream>
#include <functional>

std::function<int(int)> CreateMulLambda(int x){
    return [x](int param) noexcept { return x * param; };
}

int main(){
    const auto lam = CreateMulLambda(10);
    std::cout << sizeof(lam);
    return lam(2);
}
/* output:
 * 64
 */

C++

使用'std::function'需要指定函数签名(函数返回类型及参数类型)并包含额外的头文件'<function>'。 'std::function'是一个较大的对象，在 CLANG 18 中的大小为 64 字节！

这一缺点在 C++14 中得到了改进，使得代码可以大幅简化的同时性能更高：

#include <iostream>

auto CreateMulLambda(int x) noexcept{
    return [x](int param){ return x * param; };
}

int main(){
    const auto lam = CreateLambda(10);
    std::cout << sizeof(lam);
    return lam(2);
}
/* output:
 * 4
 * 20
 */

C++

现在完全可以使用编译时类型推导来取代辅助类型，在 CLANG 18 中，lambda 表达式的大小仅为 4 字节，比使用'std::function'的内存开销要小得多，同时赋予函数'createMulLambda' noexcept 属性，确保其不会抛出任何异常，但在使用'std::function'时不能这么做。

带初始化器的捕获

在 C++14 中， Lambda 表达式可以在捕获列表中创建新的成员变量并进行初始化，这一特性被称为带初始化器的捕获或者广义 Lambda 捕获：

#include <iostream>
int main(){
    int x = 30;
    int y = 12;
    const auto foo = [z = x + y]() { std::cout << z << '\n'; };
    x = 0;
    y = 0;
    foo();
}
/* output:
 * 42
 */

C++

在上面的代码中，编译器生成了一个新成员变量'z'，并将其初始化为'x+y'，新变量的类型通过自动类型推导确定，相当于：

auto z = x + y;

C++

Lambda 表达式等价于以下简化的仿函数：

struct _unnamedLambda{
    void operator ()() const{
        std::cout << z << '\n';
    }
    int z;
} someInstanc;

C++

新变量'z'在 Lambda 表达式定义时被初始化，而不是在调用时被初始化，因此在定义 Lambda 之后修改'x'或'y'的值，'z'的值也不会改变。

引用作为带初始化器的捕获

通过带初始化器的捕获，可以灵活地创建对外部作用域变量的引用：

#include <iostream>
int main(){
    int x = 30;
    const auto foo = [&z = x]() { std::cout << z << 'n\'; };
    foo();
    x = 0;
    foo();
}
/* output:
 * 30
 * 0
 */

C++

在上面的例子中，'z'是对'x'的引用，相当于：

auto& z = x;

C++

因此，当'x'改变时，'z'也会随之变化。

局限性

尽管 C++14 中可以使用带初始化器的捕获，但存在一些限制：

不能使用右值捕获：
- 不能使用右值引用'&&'进行捕获：
[&&z = x] // invalid syntax
不支持参数包：
- 不能在初始化器的捕获中使用参数包。
一个简单捕获后跟省略号是一个包扩展([temp.variadic])。带初始化器的捕获后根省略号是无效的。
- 即在 C++14 中，这样的语法是错误的：
template <class... Args> auto captureTest(Args... args){ return [ ...capturedArgs = std::move(args) ] (){}; }

改进现有问题

C++14 的新特性解决了一些现有问题，例如只能移动类型(only moveable type)的问题，以及一些额外的优化。

移动(move)

在 C++11 中，无法按值捕获'unique_ptr'，只能按引用捕获。C++14 允许将对象移动到闭包类型的成员中：

#include <iostream>
#include <memory>

int main(){
    std::unique_ptr<int> p(new int{10});
    const auto bar = [ptr = std::move(p)] {
        std::cout << "pointer in lambda: " << ptr.get() << '\n';
    };
    std::cout << "pointer in main(): " << p.get() << '\n';
    bar();
}
/* output:
 * pointer in main(): 0
 * pointer in lambda: 0x141420
 */

C++

通过捕获初始化器，可以将指针的所有权移动到 Lambda 中，如上面的代码段，'unique_ptr'在闭包对象创建后立即被置为'nullptr'，而在调用 Lambda 表达式时，指针地址仍然有效。

与'std::function'的兼容性问题

如果在 Lambda 表达式中捕获一个只能移动的变量，会使闭包对象不可复制，这在需要将 Lambda 存储到'std::function'中时会产生问题，因为'std::function'只接受可复制的可调用对象。

#include <functional>
#include <iostream>
.....
std::unique_ptr<int> p(new int{10});
std::function<void()> fn = [ptr = std::move(p)](){};    // compile error

C++

优化

捕获初始化器也可以用作潜在的优化技术。通过在捕获初始化器中计算某些值，可以避免在每次调用 Lambda 表达式时重复计算：

#include <iostream>
#include <string>
#include <vector>

int main(){
    using namespace std::string_literals;
    const std::vector<std::string> vs = {"apple", "orange", "foobar", "lemon" };
    const auto prefix = "foo"s;

    auto result = std::find_if(vs.begin(), vs.end(),
        [&prefix](const std::string& s){
            return s == prefix + "bar"s;
        }
    );
    if(result != vs.end()) std::cout << prefix << "-something found!\n";

    result = std::find_if(vs.begin(), vs.end(),
        [savedString = prefix + "bar"s](const std::string& s){
            return s == savedString;
        }
    );
    if(result != vs.end()) std::cout << prefix << "-something found!\n";
}

C++

在第一种调用中，每次调用 Lambda 表达式时都会计算字符串的和，在第二个调用中，通过初始化器(声明即初始化)只计算一次字符串的和，从而优化了性能。

捕获成员变量

捕获初始化器还可以用于捕获成员变量的副本，避免空悬引用的问题：

#include <iostream>
#include <algorithm>

struct Baz{
    auto foo() const{
        return [s = s] { std::cout << s << '\n'; }
    }
    std::string s;
};

int main(){
    const auto f1 = Baz{"abc"}.foo();
    const auto f2 = Baz{"xyz"}.foo();
    f1();
    f2();
}
/* output:
 * abc
 * xyz
 */

C++

在'foo()'中，通过复制成员变量到闭包类型来捕获它，此外，使用'autp'推导成员函数'foo()'的返回类型。
注意：使用'[s = s]'语法时，捕获的变量在闭包类型的作用域中，因此没有冲突。

泛型 Lambda

早期的 Lambda 规范允许创建匿名函数对象并将它们传递给标准库中的各种泛型算法，然而，闭包本身并不是“泛型”的，因为不能将模板参数指定为 Lambda 表达式的参数。但是，在 C++14 的标准中引入了泛型 Lambda 表达式：

const auto foo = [](auto x, int y){
    std::cout << x << ", " << y << '\n';
};

foo(10, 1);
foo(10.1234, 2);
foo("hello world", 3);

C++

Lambda 表达式中的'auto x'相当于在闭包类型的调用运算符中使用模板声明：

struct{
    template<typename T>
    void operator()(T x, int y) const{
        std::cout << x << ", " << y << '\n';
    }
} someInstances;

C++

如果有更多'auto'参数，代码将扩展为单独的参数模板：

const auto fooDouble = [](auto x, auto y) { /*...*/ };

C++

展开为：

struct{
    template<typename T, typename U>
    void operator()(T x, U y) const { /*...*/ }
} someOtherInstance;

C++

可变参数泛型

如果要使用更多的'auto'函数参数，还可以使用“可变参数”：泛型可变参数 Lambda 表达式求和：

#include <iostream>

template<typename T>
auto sum(T x) { return x; }

template<typename T1, typename ... T>
auto sum(T1 s, T... ts) { return s + sum(ts...); }

int main(){
    const auto sumLambda = [](auto ... args){
        std::cout << "sum of: " << sizeof...(args) << " numbers\n";
        return sum(args...);
    };
    std::cout << sumLambda(1.1, 2.2, 3.3, 4.4);
}
/* output:
 * sum of 4 numbers:
 * 11
 */

C++

在上面的代码示例中，泛型 Lambda 表达式使用'auto...'来表示可变参数包，本质上，它被扩展为如下调用运算符：

struct __anonymousLambda{
    template<typename ... T>
    void operator()(T... args) const { /*...*/ };

};

C++

在 C++17 中出现了折叠表达式(fold expression)，它可以进一步改进泛型可变参数 Lambda。

使用泛型 Lambda 实现完美转发

使用泛型 Lambda 表达式时，不仅可以使用'auto x'，还可以像其他'auto'变量一样添加任何限定符，如'auto&'、'const auto&'或'auto&&'。其中一个非常有用的用法时指定'auto&& x'，这会变成一个转发(通用)引用，从而实现完美转发输入参数。

#include <iostream>
#include <string>

void foo(const std::string& ) { std::cout << "foo(const string&)\n"; }
void foo(std::string&& ) { std::cout << "foo(const string&&)\n"; }

int main(){
   const auto callFoo = [](auto&& str){
      std::cout << "Calling foo() on: " << str << '\n';
      foo(std::forward<decltype(str)>(str));
   };

   const std::string str = "Hello World";
   callFoo(str);
   callFoo("Hello world Ref Ref");
}
/* output:
 * Calling foo() on: Hello World
 * foo(const string&)
 * Calling foo() on: Hello World Ref Ref
 * foo(string&&)
 */

C++

上述代码定义了两个'foo'函数的重载版本：一个接受'const std::string&'参数，另一个接受'std::string&&"参数，'callFoo'这个 Lambda 表达式使用了一个通用引用参数，如果将这个 Lambda 表达式重写为一个常规函数模板，其构成大概如下所示：

template<typename T>
void callFooFunc(T&& str){
   std::cout << "Calling foo() on: " << str << '\n';
   foo(std::forward<T>(str));
}

C++

推导正确类型

当类型推导比较棘手时，泛型 Lambda 可能非常有用，例如：

#include <iostream>
#include <algorithm>
#include <map>
#include <string>

int main(){
   const std::map<std::string, int> numbers{
      {"one", 1},
      {"two", 2},
      {"three", 3}
   };
   // each time entry is copied from pair<const string, int>
   std::for_each(std::begin(numbers), std::end(numbers),
      [](const std::pair<std::string, int>& entry){
         std::cout << entry.first << " = " << entry.second << '\n';
      }
   );
}
/* output:
 * one = 1
 * three = 3
 * two = 2
 */

C++

问题与解决方法

此处有个错误，'std::map'的值类型是'std::pair<const Key, T>'，而不是'const std::pair<Key, T>'。代码因为'std::pair<const std::string, int>'和'const std::pair<std::string, int>&'之间的转换而导致了额外的复制，此处可以用'auto'解决：

std::for_each(std::begin(numbers), std::end(numbers),
   [](const auto& entry){
      std::cout << entry.first << " = " << entry.second << '\n';
   }
);

C++

完整示例：

#include <iostream>
#include <algorithm>
#include <map>
#include <string>

int main(){
   const std::map<std::string, int> numbers{
      {"one", 1},
      {"two", 2},
      {"three", 3}
   };

   // print address
   for(auto mid = numbers.cbegin(); mig != numbers.cend(); ++mit)
      std::cout << &mit->first << ", " << &mit->second << '\n';

      // each time entry is copied from pair<const string, int>
      std::for_each(std::begin(numbers), std::end(numbers),
         [](const std::pair<std::string, int>& entry){
            std::cout << &entry.first << ", " << &entry.second << ": "
                     << entry.first << " = " << entry.second << '\n';
         }
      );

      // this time entried are not copied from pair<const string, int>
      // they have the same addresses
      std::for_each(std::begin(numbers), std::end(numbers),
         [](const std::pair<const auto& entry){
            std::cout << &entry.first << ", " << &entry.second << ": "
                     << entry.first << ", " << entry.second << 'n';
         }
      );
}
/* output:
 * 000001E9FBD3B820, 000001E9FBD3B848
 * 000001E9FBD3B1F0, 000001E9FBD3B218
 * 000001E9FBD3B5E0, 000001E9FBD3B608
 * 0000000E9315F8B0, 0000000E9315F8D8: one = 1
 * 0000000E9315F8B0, 0000000E9315F8D8: three = 3
 * 0000000E9315F8B0, 0000000E9315F8D8: two = 2
 * 000001E9FBD3B820, 000001E9FBD3B848: one = 1
 * 000001E9FBD3B1F0, 000001E9FBD3B218: three = 3
 * 000001E9FBD3B5E0, 000001E9FBD3B608: two = 2
 */

C++

前三行显示了 map 中键和值的地址，中间三行显示了三个新的相同的地址，可能是循环迭代中的临时副本，最后三行展示了'const auto&'版本，地址与前三行i相同。

要注意的是，在键在被复制的同时，值也会被复制，如果值是一个较大的对象，那么产生的内存开销将会更大。

用 Lambda 替换 std::bind1st 和 std::bind2nd

从 C++11 开始，std::bind1st 和 std::bind2nd 这些功能已经被弃用，并在 C++17 中被移除。

像 bind1st()、bind2nd()、mem_func()等函数是在 C++98时代引入的，现在可以使用 Lambda 或其他现代方案来实现其功能。此外，当前的标准中尚未支持完美转发、可变参数模板、decltype等 C++11的技术，因此，在代码中尽量避免使用它们。

以下是已经弃用的功能列表：

unary_function()/pointer_to_unary_function()
binary_function()/pointer_to_binary_function()
bind1st()/binder1st
bind2nd()/binder2nd
ptr_fun()
mem_fun()
mem_fun_ref()

可以使用 Lambda 或自 C++11 起可用的 std::bind，或自 C++20 起可用的 std::bind_front 来替换 bind1st 和 bind2nd。

使用 std::bind1st 和 std::bind2nd 的示例：

const auto onePlus = std::bind1st(std::plus<int>(), 1);
cosnt auto twoPlust = std::bind2nd(std::minus<int>(), 1);
std::cout << onePlus(10) << ", " << minusOne(10) << '\n';

C++

在上面的代码中，onePlus 是一个由 std::plus 和固定第一个参数为 1 组成的可调用对象，其中 onePlus(n) 被扩展为 std::plus(1, n)；同样的， minusOne(n) 是一个由 std::minus 和固定第二个参数为 1 组成的可调用对象，其中 minusOne(n) 被扩展为 std::minus(n, 1)。

对上述代码使用 Lambda 进行改进：

const auto onePlus = [](int x){ return std::plus<int>()(1, x); };
const auto minusOne = [](itn x) { return std::minus<int>()(x, 1); };
std::cout << onePlus(10) << ", " << minusOne(10) << '\n';

C++

显而易见，使用 Lambda 表达式来绑定参数更加浅显易懂。

使用现代 C++ 技术

使用 std::bind

相比于'bind1st'或'bind2nd'，'std::bind'更具有灵活性：

#include <algorithm>
#include <functional>
#include <iostream>

int main(){
   using std::placeholders::_1;
   const auto onePlus = std::bind(std::plus<int>(), _1, 1);
   const auto minusOne = std::bind(std::minus<int>(), 1, _1);
   std::cout << onePlus(10) << ", " << minusOne(10) << '\n';
}
/* output:
 * 11, 9
 */

C++

'std::bind'更加灵活，因为它可以支持多个参数，甚至可以它们进行重新排列。要进行参数管理，需要使用“占位符”。在上面的例子中，使用'_1'来表示将传递给最终函数对象的第一个参数。

但与 Lambda 表达式相比较而言，Lambda 表达式仍显得更加自然：

auto lamOnePlus1 = [](int b) { return 1 + b; };
auto lamMinusOne1 = [](int b) { return b - 1; };
std::cout << lamOnePlus1(10) << ", " << lamMinusOne(10) << '\n';
/* output:
 * 11, 9
 */

C++

在 C++14 中可以使用初始化捕获来提高灵活性：

auto lamOnePlus = [a = 1](int b) { return a + b; };
auto lamMinusOne = [a = 1](int b) { return b - a; };
std::cout << lamOnePlus(10) << ", " << lamMinusOne(10) << '\n';
/* output:
 * 11, 9
 */

C++

函数组合

使用 std::bind 进行函数组合

函数组合的示例：

#include <algorithm>
#include <functional>
#include <vector>

int main(){
   using std::placeholders::_1;
   const std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9};
   const auto val = std::count_if(v.begin(), v.end(),
                                 std::bind(std::logical_and<bool>(),
                                 std::bind(std::greater<int>(), _1, 2),
                                 std::bind(std::less<int>(), _1, 6)));
   return val;
}
/* output:
 * 3
 */

C++

使用 Lambda 表达式重写函数组合

使用 Lambda 表达式示例：

std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9};
const auto more2less6 = std::count_if(v.begin(), v.end(),
                        [](int x) reutrn { return x > 2 && x < 6; });

C++

Lambda 表达式提升

在使用标准库中的算法时有一个难以解决的问题就是将函数重载传递给接受可调用对象的函数模板：

#include <algorithm>
#include <vector>

int main(){
   const std::vector<int> vi{1, 2, 3, 4, 5, 6, 7, 8, 9};
   std::for_each(vi.begin(), vi.end(), foo);
}
/* error:
 * No matching function for call to 'for_each'
 * candidate template ignored: couldn't infer template argument '_Fn'
 */

C++

此处的问题是，编译器将'foo'是为模板函数，因此需要解析其类型，但无法确定'foo'接受的类型。

使用 Lambda 表达式解决：

std::for_each(vi.begin(), vi.end(),
   [](auto x) { return foo(x); });

C++

使用一个包装器，让它处理重载解析并调用适当的'foo()'重载。

使用完美转发改进：

std::for_each(vi.begin(), vi.end(),
      [](auto&& x) { return foo(std::forward<decltype(x)>(x)); });

C++

完整示例：

#include <iostream>
#include <algorithm>
#include <vector>

void foo(int i) { std::cout << "int: " << i << '\n'; }
void foo(float f) { std::cout << "float: " << f << '\n'; }

int main(){
   const std::vector<int> vi{1, 2, 3, 4, 5, 6, 7, 8, 9};
   std::for_each(vi.begin(), vi.end(),
               [](auto&& x){
                  return foo(std::forward<decltype(x)>(x));
   });
}

C++

更通用的解决方案

对于高级的使用场景，这种方法可能不太理想，因为它不支持可变参数和异常规范，对于更通用的场景解决方案，可以使用如下宏定义：

#define LIFT(foo) \
[](auto&&... x) \
noexcept(noexcept(foo(std::forward<decltype(x)>(x)...))) \
-> decltype(foo(std::forward<decltype(x)>(x)...)) \
{ return foo(std::forward<decltype(x)>(x)...); }

C++

对上述宏解释：

'return foo(std::forward<decltype(x)>(x)...);'：这是完美转发，用于正确传递输入参数给'foo'函数并保留它们的类型。
'noexcept(noexcept(foo(std::forward<decltype(x)>(x)...)))'：使用嵌套的'noexcept'操作符来检查'foo'的异常规范，根据结果返回'noexcept(true)'或'noexcept(false)'。
'decltype(foo(std::forward<decltype(x)>(x)...))'：用于推导包装 Lambda 的返回类型。

使用'LIFT'宏定义，可以轻松地创建 Lambda 并传递给标准库中的算法进行使用。

递归 Lambda 表达式

使用常规函数实现递归

常规函数可以很容易地进行递归调用，例如，计算阶乘：

int factorial(int n) { return n > 1 ? n * factorial(n - 1) : 1; }
int main(){ return factorial(5);}
/* output:
 * 120
 */

C++

递归 Lambda 表达式的问题直接使用 Lambda 表达式实现递归是行不通的：

int main(){
   auto factorial = [](int n){
      return n > 1 ? n * factorial(n - 1) : 1;
   };
   return factorial(5);
}
/* error: variable 'factorial' declared with deduced type 'auto' cannot appear in its own initializer */

C++

无法通过编译的原因是因为在 Lambda 的主体内不能访问尚未完全评估的'factorial'。用一个仿函数来对 Lambda 表达式进行展开：

struct fact{
   int operator()(int n) const{
      return n > 1 ? factorial(n - 1) : 1;
   }
};

auto factorial = fact{};

C++

在'operator()'内无法访问仿函数类型的变量。

解决方法：

使用'std::function'并捕获它
使用内部 Lambda 并将其作为泛型参数传递

方法一：使用 std::function并捕获它

可以将 Lambda 赋值给 'std::function'并捕获他自己，从而实现递归调用：

#include <functional>
#include <iostream>

int main(){
   std::function<int(int)> factorial = [&](int n) -> int{
      return n > 1 ? n * factorial(n - 1) : 1;
   };
   std::cout << factorial(5) << '\n';
}
/* output:
 * 120
 */

C++

在这个方法中，使用'std::function'定义'factorial'并捕获他自己，从而实现递归调用。

方法二：使用内部 Lambda 并传递泛型参数

使用 C++14 的泛型 Lambda，可以避免'std::function'产生的额外内存开销：

#include <iostream>

int main(){
   const auto factorial = [](int n) noexcept{
      const auto f_impl = [](int n, const auto& impl) noexcept -> int{
         return n > 1 ? n * impl(n - 1, impl) : 1;
      };
      return f_impl(n, f_impl);
   };
   std::cout << factorial(5) << '\n';
}

C++

在这个示例中，创建一个内部 Lambda'f_impl'进行主要处理，并将其自身作为参数传递，利用 C++14 的泛型 Lambda，可以避免'std::function'的内存开销。

递归 Lambda 表达式与 Y 组合子在 C++ 中的应用

理想的递归 Lambda 解决方案

auto fib = [&fib](int64_t x) -> int64_t{
   if (x == 0 || x == 1) return 1;
   else return fib(x - 1) + fib(x - 2);
};

C++

这种方法由于无法在初始化时捕获自身而无法通过编译。

使用泛型 Lambda 的解决方案

为了绕过上述问题，可以使用 C++14 的泛型 Lambda：

auto fib = [](int64_t x, const auto& lambda) -> int64_t {
   if(x == 0 || x == 1) return 1;
   else return lambda(x - 1, lambda) + lambda(x - 2, lambda);
};

fib(35, fib);

C++

这种方法虽然可以通过编译，但是代码整体冗长且不够美观。

改进的 Lambda 方法

通过进一步封装，可以使代码更加简洁

auto fib = [](itn64_t x){
   auto lambda = [](int64_t x, const auto& lambda) -> int64_t{
      if(x == 0 || x == 1) return 1;
      else return lambda(x - 1, lambda) + lambda(x - 2, lambda);
   };
   return lambda(x, lambda);
};

C++

性能比较

比较普通函数、std::function、泛型 Lambda 的性能

#include <iostream>
#include <functional>
#include <chrono>

int64_t f(int64_t x){
    if(x == 0 || x == 1) return 1;
    else return f(x - 1) + f(x - 2);
}

int main(){
    int var = 35;

    std::function<int64_t(int64_t)> f1 = [&f1](int64_t x) -> int64_t{
        if(x == 0 || x == 1) return 1;
        else return f1(x - 1) + f1(x - 2);
    };

    auto f2 = [](int64_t x){
        auto lambda = [](int64_t x, const auto& ff) -> int64_t{
            if(x == 0 || x == 1) return 1;
            else return ff(x - 1, ff) + ff(x - 2, ff);
        };
        return lambda(x, lambda);
    };

    std::cout << "Lambda in C++14 tests\n";

    using namespace std::chrono;
    auto start1 = steady_clock::now();
    auto res1 = f(var);
    auto end1 = steady_clock::now();
    auto diff1 = end1 - start1;

    auto start2 = steady_clock::now();
    auto res2 = f1(var);
    auto end2 = steady_clock::now();
    auto diff2 = end2 - start2;

    auto start3 = steady_clock::now();
    auto res3 = f2(var);
    auto end3 = steady_clock::now();
    auto diff3 = end3 - start3;

    std::cout << "duration (normal function): " <<
    duration_cast<milliseconds>(diff1).count() << " ms\n";

    std::cout << "duration (std::function): " <<
    duration_cast<milliseconds>(diff2).count() << " ms\n";

    std::cout << "duration(auto): " <<
    duration_cast<milliseconds>(diff3).count() << " ms\n";
}
/* output:
 * Lambda in C++14 tests
 * duration (normal function): 45 ms
 * duration (std::function): 244 ms
 * duration(auto): 43 ms
 */

C++

性能：'std::function'的性能较差，泛型 Lambda 方法和普通递归函数差不多。可读性：泛型 Lambda 方法虽然有效，但代码较为冗长且不够美观。

第三章 Lambda in C++14

Lambda 表达式的默认参数

返回类型(Return Type)

返回 Lambda 表达式

带初始化器的捕获

引用作为带初始化器的捕获

局限性

改进现有问题

移动(move)

与'std::function'的兼容性问题

优化

捕获成员变量

泛型 Lambda

可变参数泛型

使用泛型 Lambda 实现完美转发

推导正确类型

问题与解决方法

用 Lambda 替换 std::bind1st 和 std::bind2nd

使用现代 C++ 技术

使用 std::bind

函数组合

使用 std::bind 进行函数组合

使用 Lambda 表达式重写函数组合

Lambda 表达式提升

更通用的解决方案

递归 Lambda 表达式

使用常规函数实现递归

方法一：使用 std::function并捕获它

方法二：使用内部 Lambda 并传递泛型参数

更多关于 Lambda 递归调用的方法

Y组合子介绍

Y组合子的定义

递归 Lambda 表达式与 Y 组合子在 C++ 中的应用

理想的递归 Lambda 解决方案

使用泛型 Lambda 的解决方案

改进的 Lambda 方法

性能比较

Leave a Comment 取消回复

CONTENTS

第三章 Lambda in C++14

Lambda 表达式的默认参数﻿

返回类型(Return Type)﻿

返回 Lambda 表达式﻿

带初始化器的捕获﻿

引用作为带初始化器的捕获﻿

局限性﻿

改进现有问题﻿

移动(move)﻿

与'std::function'的兼容性问题﻿

优化﻿

捕获成员变量﻿

泛型 Lambda﻿

可变参数泛型﻿

使用泛型 Lambda 实现完美转发﻿

推导正确类型﻿

问题与解决方法﻿

用 Lambda 替换 std::bind1st 和 std::bind2nd﻿

使用现代 C++ 技术﻿

使用 std::bind﻿

函数组合﻿

使用 std::bind 进行函数组合﻿

使用 Lambda 表达式重写函数组合﻿

Lambda 表达式提升﻿

更通用的解决方案﻿

递归 Lambda 表达式﻿

使用常规函数实现递归﻿

方法一：使用 std::function并捕获它﻿

方法二：使用内部 Lambda 并传递泛型参数﻿

更多关于 Lambda 递归调用的方法﻿

Y组合子介绍﻿

Y组合子的定义﻿

递归 Lambda 表达式与 Y 组合子在 C++ 中的应用﻿

理想的递归 Lambda 解决方案﻿

使用泛型 Lambda 的解决方案﻿

改进的 Lambda 方法﻿

性能比较﻿

Leave a Comment 取消回复