本文将详解Lambda函数从定义到学习和使用,涉及一些不为人知的事情,如LIFE-立即调用的函数表达式,Lambda的类型。相信你已经起了兴趣,那就开始阅读吧。

lambda是多用还是慎用(贯穿C11)(1)

作者 | Vishal Chovatiya

译者 | 苏本如,责编 | maozz

出品 | CSDN(lambda是多用还是慎用(贯穿C11)(2)ID:CSDNnews)

以下为译文:

lambda是多用还是慎用(贯穿C11)(3)

Lambda函数是C 11中引入的现代C 的一个直观概念,因此在互联网上可以找到大量的关于Lambda函数的文章。但是仍然有一些不为人知的事情(如LIFE-立即调用的函数表达式,Lambda的类型等等)鲜有人谈论。因此,在这篇文章里,我不仅要向你展示C 中的Lambda函数,同时还要介绍它的内部工作机制,以及Lambda函数的其他方方面面。

这篇文章的标题有点误导人。因为Lambda并不总是转化为函数指针。实际上它是一个表达式(确切地说是唯一的闭包)。为了简单起见,在这篇文章中,我会一直互换使用Lambda函数和Lambda表达式。

lambda是多用还是慎用(贯穿C11)(4)

什么是Lambda函数?

Lambda函数是简短的代码片段,它:

不值得命名(匿名的、未被命名的、一次性的,等等,无论你怎么称呼它),

也不能重复使用。

换句话说,它只是一种糖衣语法(syntactic sugar)。Lambda函数的语法定义如下:

[ capture list ] (parameters) -> return-type

{ method definition

}

编译器通常会计算Lambda函数本身的返回类型。因此,我们不需要显式地给它指定一个尾置返回类型,如-> return-type。

但在一些复杂的情况下,编译器无法推断返回类型,这时候我们就需要给它指定一个返回类型。

lambda是多用还是慎用(贯穿C11)(5)

为什么我们要使用Lambda函数?

C 包含许多有用的通用函数,如std::for_each,它们可以很方便。不幸的是,它们的使用有时也很麻烦,特别是如果你想应用的函子是特定函数的唯一函子的话。以下面的代码为例:

struct print

{

void operator(int element)

{

cout << element << endl;

}

};

int main(void)

{

std::vector<int> v = {1, 2, 3, 4, 5};

std::for_each(v.begin, v.end, print);

return 0;

}

如果你只是在特定的地方使用一次print,那么仅仅为了做一些琐碎的和一次性的事情而编写一个完整的类,就显得有些过犹不及了。

对于上面的这种情形,使用内联代码会更合适,这可以通过Lambda函数来实现,如下所示:

std:for_each(v.begin, v.end, (int element) { cout << element << endl; });

lambda是多用还是慎用(贯穿C11)(6)

Lambda函数内部是如何工作的?

[&i] { std::cout << i; }

// is equivalent to

struct anonymous

{

int &m_i;

anonymous(int &i) : m_i(i) {}

inline auto operator const

{

std::cout << i;

}

};

编译器为每个Lambda函数生成如上所述的唯一闭包。注意,这是Lambda函数的核心所在。

捕获列表将成为闭包中的构造函数的参数,如果将参数按值捕获,那么相应类型的数据成员将在闭包中创建。

此外,可以在Lambda函数的参数中声明变量/对象,它们将成为调用operator函数的参数。

lambda是多用还是慎用(贯穿C11)(7)

使用Lambda函数的好处

零成本抽象。对!你没有看错。Lambda函数不会降低性能,它的性能和普通的函数一样好。

此外,Lambda函数使代码变得更加紧凑、更加结构化和更富有表现力。

lambda是多用还是慎用(贯穿C11)(8)

学习Lambda表达式

按引用/值来捕获,代码如下:

int main

{

int x = 100, y = 200;

auto print = [&] { // Capturing object by reference

std::cout << __PRETTY_FUNCTION__ << " : " << x << " , " << y << std::endl;

};

print;

return 0;

}

上面代码的输出如下:

main::<Lambda> : 100 , 200

在上面的例子中,我在捕获列表中对“&”符号作了注释。它表示按引用来捕获变量x和y。类似地,“=”符号表示按值捕获,它将在闭包中创建相同类型的数据成员,并且将执行copy-assignment操作。

请注意,参数列表是可选的,如果你不向Lambda表达式传递任何参数,则可以省略空括号。

lambda是多用还是慎用(贯穿C11)(9)

Lambda函数的捕获列表

下表显示了捕获列表中不同用法的含义:

lambda是多用还是慎用(贯穿C11)(10)

将Lambda函数作为参数传递,代码如下:

template <typename Functor>

void f(Functor functor)

{

std::cout << __PRETTY_FUNCTION__ << std::endl;

}

/* Or alternatively you can use this

void f(std::function<int(int)> functor)

{

std::cout << __PRETTY_FUNCTION__ << std::endl;

}

*/

int g { static int i = 0; return i ; }

int main

{

auto Lambda_func = [i = 0] mutable { return i ; };

f(Lambda_func); // Pass Lambda

f(g); // Pass function

}

上面代码的输出如下:

Function Type : void f(Functor) [with Functor = main()::<Lambda(int)>]

Function Type : void f(Functor) [with Functor = int (*)(int)]

你还可以将Lambda函数作为参数传递给其他函数,就像我在上面编写的普通函数一样。

如果你注意到了,这里我在捕获列表中声明了变量i,它将成为数据成员。因此,每次调用Lambda_func时,它都将返回并递增。

捕获Lambda函数中的成员变量或this指针,代码如下:

class Example

{

public:

Example : m_var(10) {}

void func

{

[=] { std::cout << m_var << std::endl; }; // IIFE

}

private:

int m_var;

};

int main

{

Example e;

e.func;

}

也可以使用[this], [=] 或者 [&]来捕获This指针。在任何这些情况下,类中的数据成员(包括private类型的数据成员)都可以像在普通方法中那样被访问。

如果你看到Lambda表达式行,我在Lambda函数声明的末尾使用了额外的 ,这个额外的 用来表示在声明之后立即调用它,它被称为IIFE(立即调用的函数表达式)。

lambda是多用还是慎用(贯穿C11)(11)

C 的Lambda函数类型

泛型Lambda,代码如下:

const auto l = (auto a, auto b, auto c) {};

// is equivalent to

struct anonymous

{

template <class T0, class T1, class T2>

auto operator(T0 a, T1 b, T2 c) const

{

}

};

在C 14中引入的泛型Lambda,它可以使用auto标识符捕获参数。

可变泛型Lambda,代码如下:

void print {}

template <typename First, typename... Rest>

void print(const First &first, Rest &&... args)

{

std::cout << first << std::endl;

print(args...);

}

int main

{

auto variadic_generic_Lambda = (auto... param) {

print(param...);

};

variadic_generic_Lambda(1, "lol", 1.1);

}

带可变参数包的Lambda在许多情况下都很有用,如代码调试、不同数据输入的重复操作等。

可变(Mutable)Lambda函数

通常,Lambda函数的call-operator(调用运算符)隐式为const-by-value(常量,按值捕获),这意味着它是不可变的。如果要按值捕获任何内容,需要在Lambda函数体前使用mutable关键字。代码如下所示:

mutable {}

// is equivalent to

struct anonymous

{

auto operator // call operator

{

}

};

我们已经在上面看到了上述情况的一个例子。希望你注意到了。

Lambda作为函数指针,代码如下:

#include <iostream>

#include <type_traits>

int main

{

auto funcPtr = {};

static_assert(std::is_same<decltype(funcPtr), void (*)>::value);

}

你可以强制编译器生成Lambda作为函数指针,而不是像上面那样在它前面添加 来使之成为闭包。

高阶函数:Lambda可以作为参数和返回值,代码如下:

const auto less_than = (auto x) {

return [x](auto y) {

return y < x;

};

};

int main(void)

{

auto less_than_five = less_than(5);

std::cout << less_than_five(3) << std::endl;

std::cout << less_than_five(10) << std::endl;

return 0;

}

再进一步,Lambda函数还可以返回另一个Lambda函数。这将为代码的定制、代码表示性和紧凑性(顺便说一句,没有这样的词)打开无限可能的大门。

lambda是多用还是慎用(贯穿C11)(12)

constexpr Lambda表达式

从C 17开始,Lambda表达式可以被声明为constexpr(常量表达式)。

constexpr auto sum = (const auto &a, const auto &b) { return a b; };

/*

is equivalent to

constexpr struct anonymous

{

template <class T1, class T2>

constexpr auto operator(T1 a, T2 b) const

{

return a b;

}

};

*/

constexpr int answer = sum(10, 10);

即使你没有指定constexpr关键字,如果函数调用运算符恰好满足所有constexpr函数的要求,那么它也将是constexpr。

lambda是多用还是慎用(贯穿C11)(13)

结束语

希望你喜欢这篇文章。我试着用几个简单的小例子来涵盖使用Lambda的大多数复杂情况。考虑到代码的表达性和易维护性,你应该在满足Lambda使用条件的所有地方都优先使用它,就像你可以将其和大多数STL算法一起用于智能指针的自定义删除器中一样。

原文:https://hackernoonlambda是多用还是慎用(贯穿C11)(14).com/all-about-Lambda-functions-in-cfrom-c11-to-c17-2t1j32qw

本文为 CSDN 翻译,转载请注明来源出处。

,