C++17之lambda扩展

最新推荐文章于 2024-06-02 16:54:13 发布
最新推荐文章于 2024-06-02 16:54:13 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： C++17 C++ 文章标签： c++17 lambda扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/janeqi1987/article/details/100176985
版权
C++ 同时被 2 个专栏收录
66 篇文章 26 订阅
订阅专栏
C++17
30 篇文章 17 订阅
订阅专栏

 

 

c++ 11引入的Lambdas和用c++ 14引入的generic Lambdas都是成功的例子。lambda的使用使得我们在一些地方比函数方便很多。
c++ 17改进了lambda的功能，允许在更多的地方使用lambdas:

  1. 在constant表达式(即，在编译时期)；

  2. 在需要当前对象副本的地方(例如，在线程中调用lambdas时)。

1. constexpr lambda

 

从c++ 17起，如果lambda表达式符合编译时期constexpr的要求的话，lambdas会隐式转换为constexpr表达式。也就是说，任何lambda都可以在编译时上下文中使用，前提是它使用的特性对编译时上下文中有效。即满足如下要求：

  • lambda表达式内没有静态变量；
  • lambda表达式内没有虚函数；
  • lambda表达式内没有 try/catch语句；
  • lambda表达式内没有new/delete；

传递一个编译时期的值做为lambda表示的参数，并用lambda表达式求平方的结果用来声明std::array<>:

例1：

#include <iostream>
#include <array>

auto squared = [](auto val) { // implicitly constexpr since C++17
	return val * val;
};

int main()
{
	std::array<int, squared(5)> arr; // OK since C++17 => std::array<int,25>

	auto size = arr.size();

	return 0;
}

结果如下：

constexpr lambda也就意味着还可以在constexpr 函数中用lambda表达式了，这在C++17之前是不允许的。这样使用constexpr函数和普通函数没多大区别了，使用起来非常舒服。下面是constexpr lambda的例子： 

#include <iostream>

template <typename I>
constexpr auto func(I i)
{
	//use a lambda in constexpr context  

	return [i](auto j) { return i + j; };

}

int main(void)
{
	const auto ret = func(10)(2);

	std::cout << ret << std::endl;

	return 0;
}

运行结果如下：

 

如果不满足constexpr lambda的要求，则不能转换为constexpr表达式,但是仍然可以在运行时期使用lambda:

auto squared2 = [](auto val) { 
static int calls = 0; // OK, but disables lambda for constexpr contexts
...
return val*val;
};

std::array<int,squared2(5)> a; // ERROR: static variable in compile-time context
std::cout << squared2(5) << '\n'; // OK

如果不能确定lambda是否是constexpr表达式，可以将其声明为constexpr来让编译器判断：

auto squared3 = [](auto val) constexpr { // OK since C++17
return val*val;
};

对于指定返回类型的constexpr lambda语法如下:

auto squared3i = [](int val) constexpr -> int { // OK since C++17
return val*val;
};

对于lambda表达式，如果声明了constexpr但是又使用了不满足constexpr lambda的语句，则为编译错误：

例2：

#include <iostream>
#include <array>

auto squared4 = [](auto val) constexpr
{
	static int calls = 0; // ERROR: static variable in compile-time context
	return val * val;
};

int main()
{
	constexpr int size = squared4(2);
	return 0;
}

编译错误信息如下：

对于隐式或显式的constexpr lambda，函数调用操作符是constexpr。也就是说，如下定义：

auto squared = [](auto val) { // implicitly constexpr since C++17
return val*val;
};

转换为闭包类型:

class CompilerSpecificName
{
    public:
    ...
    template<typename T>
    constexpr auto operator() (T val) const
    {
        return val*val;
    }
};

注意，这里生成的闭包类型的函数调用操作符是自动constexpr。一般来说，自从c++ 17，如果lambda被显式定义为constexpr，或者它是隐式的constexpr(就像这里的情况一样)，那么生成的函数调用操作符就是constexpr。

#include <iostream>
#include <array>

int main()
{
    constexpr auto add1 = [](int n, int m){
        auto func1 = [=] { return n; }; //func1  lambda表达式
        auto func2 = [=] { return m; }; //func2  lambda表达式
        return [=] { return func1() + func2(); };  //注意返回的是lambda表达式类型
    };
    constexpr auto add2 = [](int n, int m){
        return n + m;
    };
    auto add3 = [](int n, int m){
        return n + m;
    };
    int sum1 = add1(30, 40)( ); //传入常量值，add1在编译期计算，立即返回70，由于add1返回的是lambda表达式类型，所以第二个()是必须的；
    int sum2 = add2(sum1, 4); //由于传入非constexpr变量，add2的constexpr失效，变成运行期lambda
    constexpr int sum3 = add3(1, 2); //sum3为constexpr变量，传入常量值，add3变成编译期lambda，立即返回3
    int sum4 = add2(10, 2);//传入常量值，add2在编译期计算，立即返回12


    constexpr auto add4 = [](int n, int m){
        auto func1 = [=] { return n; }; //func1  lambda表达式
        auto func2 = [=] { return m; }; //func2  lambda表达式
        return func1() + func2(); //注意返回的是整形，不是lambda表达式类型
    };

    {
        constexpr int sum1 = add4(30, 40);//传入常量值，add1在编译期计算，立即返回70
        int sum2 = add2(sum1, 4); //由于传入的参数都是constexpr变量，add2的constexpr生效，也是编译期的lambda,立即返回74
        constexpr int sum3 = add3(1, 2); //sum3为constexpr变量，传入常量值，add3变成编译期lambda，立即返回3
        int sum4 = add2(sum2, 2);//传入非constexpr常量值，add2的constexpr失效，变成运行期lambda

        std::array<int, add4(30, 40)> arr;
        std::array<int, sum1> arr2;
        std::array<int, add2(sum1, 4)> arr3;
        std::array<int, sum3> arr4;
    }


    return 0;
}

2. 传递this拷贝到lambda

当在成员函数中使用lambda时，您不能隐式地访问调用成员函数的对象。也就是说，在lambda内部，如果不以任何形式捕获它，就不能使用对象的成员(独立于是否用this->限定它们):

#include <iostream>
#include <string>

class NoThisCaptureInLambda
{
private:
	std::string name;
public:
	void foo()
	{
		auto l1 = [] { std::cout << name << '\n'; }; // ERROR
		auto l2 = [] { std::cout << this->name << '\n'; }; // ERROR
	}
};

int main()
{
	return 0;
}

编译错误信息如下：

在c++ 11和c++ 14中，您必须通过值或引用传递此值:

#include <iostream>
#incldue <string>

class ThisCaptureInLambda
{
private:
	std::string name;
public:
	void foo()
	{
		auto l1 = [this] { std::cout << name << '\n'; }; // OK
		auto l2 = [=] { std::cout << name << '\n'; }; // OK
		auto l3 = [&] { std::cout << name << '\n'; }; // OK
	}
};

    然而这里的问题是，即使进行了this捕获，也是通过引用捕获了底层对象(因为只复制了this指针)。如果lambda的生存期超过调用成员函数的对象的生存期，这就会成为一个问题。一个关键的例子是当lambda定义一个新线程的任务时，该线程应该使用它自己的对象副本来避免任何并发性或生存期问题。另一个原因可能只是传递对象的副本及其当前状态。

从c++ 14开始就有了一种变通方法：

例3：

#include <iostream>
#include <string>

class ThisCopyInLambda
{
private:
	std::string name;
public:
	ThisCopyInLambda(std::string name) : name{ name }
	{
	}

	void foo()
	{
		auto l1 = [*this](){
			std::cout << name << '\n';
		};
		l1();
	}

};

int main()
{
	ThisCopyInLambda thisCopy("This copy test in lambda");

	thisCopy.foo();

	return 0;
}

 结果如下：

虽然满足了我们的期望，但是它的可读性差。而且，程序员在使用=或&捕获其他对象时仍然可能意外地使用name这个变量:

例4：

#include <iostream>
#include <string>

class ThisCopyInLambda
{
private:
    mutable std::string name;
public:
    ThisCopyInLambda(std::string name): name{name}
    {
    }

    void foo()
    {
        auto l1 = [=, thisCopy = *this](){
        thisCopy.name = "new name";
        std::cout << thisCopy.name << std::endl;
        std::cout << name << '\n'; //still the old name
        name = "this is temorary string";
        std::cout << name << '\n'; //the new value

        std::cout << thisCopy.name << std::endl; //和name是两个独立的对象
        };

        l1();
    }
    void display()
    {
        std::cout << name << '\n';
    }
};

int main()
{
    ThisCopyInLambda thisCopy("This copy test in lambda");

    thisCopy.foo();

    thisCopy.display();

    return 0;
}

结果如下：

 

    

从c++ 17，你可以显式地要求捕获当前对象的副本，方法是捕获*this:

#include <iostream>
#include <string>

class ThisCopyInLambda
{
private:
    mutable std::string name;
public:
    ThisCopyInLambda(std::string name): name{name}
    {
    }

    void foo()
    {
        auto l1 = [*this](){

        std::cout << name << std::endl;
        name = "this is temorary string";
        std::cout << name << '\n';
        };

        l1();
    }
    void display()
    {
        std::cout << name << '\n';
    }
};

int main()
{
    ThisCopyInLambda thisCopy("This copy test in lambda");

    thisCopy.foo();

    thisCopy.display();//still old value

    return 0;
}

也就是说，捕获*this意味着将当前对象的副本传递给lambda。你仍然可以将捕获*this与其他捕获相结合，只要和this没有矛盾:

auto l2 = [&, *this] { ... }; // OK
auto l3 = [this, *this] { ... }; // ERROR

一个完整的例子：

例3：

#include <iostream>
#include <string>
#include <thread>

class Data {
private:
	std::string name;
public:
	Data(const std::string& s) : name(s) {
	}
	std::thread startThreadWithCopyOfThis() const 
        {
	    // start and return new thread using this after 3 seconds:
	    std::thread t([*this]
            {
	         std::cout << "I will shellp 3 seconds" << std::endl;
                 std::this_thread::sleep_for(std::chrono::seconds(3));
                 std::cout << name << std::endl;
	    });
	    return t;
	}
};

int main()
{
	std::thread t;
	{
	    Data d{ "This copy capture in C++17" };
	    t = d.startThreadWithCopyOfThis();
	} // d已经销毁
	std::cout << "the main thread wait for sub thread end." << std::endl;
	t.join();
	return 0;
}

结果如下：

如果修改13代码中的*this为this,则结果可能如下：

lambda中的*this是一个拷贝，这意味着传递了d的一个拷贝。因此，线程在调用d的析构函数后使用传递的对象是没有问题的。
如果我们用[this]、[=]或[&]捕获了，那么线程将运行未定义的行为，因为在传递给线程的lambda中打印name时，lambda将使用已销毁对象的成员。

 

C++17中，我们可以在lambda表达式的捕获类别里[]写上*this,表示传递到lambda中的是this对象的拷贝。从而解决上述的问题。（注：C++11中是不允许这样写的。成员捕获列表中只能是变量、”=“、”&“、”=， 变量列表“、”&， 变量列表“ ）
 

C咖咖
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++新特性之二：对语言运行期的强化
实战开发者Airex
04-30 173
总第31篇 本文主要详细介绍C++11/14中对语言运行期强化的一些新特性。方便大家在学习工作过程中参考，对于文中疏漏部分，也欢迎大家批评指正。 1.Lambda表达式 匿名函数可以说是现代编程语言的标配，C++11中提供的lambda表达式，实际上类似匿名函数的特性，其表达式的语法如下： [...
C++17(6) : lambda扩展
Polizi的博客
05-29 664
一、constexpr Lambda 自从C++17开始，如果lambda表达式符合要求的话，该表达式会隐式转换为constexpr表达式。（表达式内没有静态变量，没有虚函数，没有 try/catch语句， 没有new/delete关键字）。如下: auto squared = [](auto val) { return val*val; };//隐式转换为constexpr...
C++11中的Lambda表达式
weixin_34387284的博客
10-20 136
原文地址：C++中的Lambda表达式 作者：果冻想 　　一直都在提醒自己，我是搞C++的；但是当C++11出来这么长时间了，我却没有跟着队伍走，发现很对不起自己的身份，也还好，发现自己也有段时间没有写C++代码了。今天看到了C++中的Lambda表达式，虽然用过C#的，但是C++的，一直没有用，也不知道怎么用，就可怜的连Lambda语法都看不懂。好了，这里就对C++中的Lambda进行...
C++17新特性
最新发布
qq_44660367的博客
06-02 748
C++17是C++标准中的一个重要版本，它在语言核心和标准库中引入了许多新特性和改进，使得C++编程更加现代化和高效。、内联变量、新的标准属性以及文件系统库。是一个标准库类型，用于表示一个可能包含值也可能不包含值的对象，这在需要返回可能无效的结果时非常有用。结构化绑定允许将结构体、数组、元组等的成员解构到独立的变量中，简化了代码书写和提高了可读性。是一个类型安全的联合体，可以存储多个类型中的一种，并确保在访问时进行类型检查。是一个类型安全的容器，可以存储任意类型的值，类似于一个类型擦除的容器。
C++17中lambda表达式新增加支持的features
网络资源是无限的
01-27 1115
C++17中lambda表达式新增加支持的features
C++—— Lambda表达式
zy2317878的博客
03-03 433
写在前面 这是对于C++11中新添加的Lambda表达式的学习总结，截至目前遇到过两次这样的题目。可参考：LeetCode-520. Detect Capital、LeetCode-406. Queue Reconstruction by Height、 LeetCode-155. Min Stack。 利用Lambda表达式，可以方便的定义和创建匿名函数。对于C++这门语言来说来说，“Lam...
C++ Lambda Story
02-18
C++20继续扩展Lambda表达式的能力，引入了函数指针兼容性，这意味着Lambda表达式可以直接转换为相应的函数指针类型，进一步提高了Lambda的通用性。此外，还引入了协程（coroutines），这与Lambda表达式相结合，可以...
实例讲解C++编程中lambda表达式的使用
09-02
C++中的Lambda表达式是C++11标准引入的一个强大特性，它允许程序员在需要的地方直接定义匿名函数，极大地提高了代码的简洁性和可读性。Lambda表达式在处理函数式编程风格的问题时特别有用，例如在STL算法中，它可以...
C++17新特性个人总结
08-18
C++17中，constexpr的使用范围扩展到了if语句和lambda表达式中。constexpr是C++11中引入的一种常量表达式，它可以在编译期进行计算。示例代码中，constexpr void foo() 函数在编译期进行判断，如果ok为true，则输出...
结合C++11新特性来学习C++中lambda表达式的用法
09-02
C++14标准进一步扩展了lambda表达式，引入了**初始化捕获**（init-capture），允许在捕获列表中初始化变量。例如： ```cpp auto square = [value = 5] { return value * value; }; ``` 这里，`value`被初始化为5，...
C++ 17 标准手册.rar
08-23
C++ 17是C++编程语言的一个重要版本，它引入了许多新的特性和改进，...这些特性极大地扩展了C++的表达力和效率，使得C++ 17成为现代软件开发的强大工具。学习并掌握这些知识点对于任何C++开发者来说都是至关重要的。
C++ 11，14，17中的 Lambda 表达式 _ Microsoft Docs[2].pdf
03-27
查Lambda表达式资料时很容易被函数闭包、Lambda演算、形式系统这些深奥名词淹没而放弃学习，其实Lambda表达式就是匿名函数（annoymous function）——允许我们使用一个函数，但不需要给这个函数起名字。还是有点难懂？没关系，看完此资料就清楚了。 c++11，14，17新增Lambda详解
C++11特性（17）：lambda函数
caychen的博客
03-29 1231
#include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; //for_each... #include &lt;functional&gt; //plus&lt;int&gt;()... #include &lt;numeric&gt; //accumulate... //l...
C++(17)：lambda捕获this的副本
风静如云的博客
11-22 1026
copy construct this:0x63fd6c //函数t中return a1.func,会拷贝构造一个新的临时对象tmp1。会拷贝构造一个新的临时对象tmp2。this addr:0x63fdcc data:6 //doF调用lambda函数f访问了已经析构了的a1对象。this addr:0x63fe0c data:8 //在临时对象tmp2上调用函数doF。destruct this:0x63fdcc //函数t离开作用域，a1析构。
C++11-17中的lambda
路漫漫其修远兮
12-21 1029
文章目录可调用对象谓词lambda捕捉列表值捕获引用捕获可变lambda：mutable异常说明指定lambda返回类型lambda 捕捉表达式泛型lambdaconstexpr lambda向lambda传递this的拷贝参考资料 可调用对象   可调用对象，有函数、函数指针、重载了函数调用运算符的类（也就是仿函数）、lambda表达式四种形式。这里主要介绍lambda的作用。 谓词   先看下...
C++(17)：constexpr lambda
风静如云的博客
11-28 260
C++17增加了constexpr lambda，可以将lambda表达式用于编译器常量。
Visual Studio 11开发指南（17）C++11更新- Lambda表达式
尹成的技术博客
01-16 3866
Visual Studio 2010 年以来有可能在 c + + 代码中，和更具体地 STL 使用 Lambda 表达式 （匿名方法的窗体）。例如，看下面的代码执行，当使用这些类型的算法for_each、 parallel_for、 parallel_for_each等等的时候。1.std::deque d1; 2. d1.push_back (2); 3. d1.push_bac
C++ lambda 捕获模式与右值引用
tq08g2z的专栏
03-22 1735
lambda 表达式和右值引用是 C++11 的两个非常有用的特性。 lambda 表达式实际上会由编译器创建一个 std::function 对象，以值的方式捕获的变量则会由编译器复制一份，在 std::function 对象中创建一个对应的类型相同的 const 成员变量，如下面的这段代码： int main() { std::string str = "test"; printf("...
C++17新特性（二）模板特性
CHAKMING1的博客
01-19 697
本篇文章也是介绍C++17的知识（关于模板的变化），在学习这部分知识之前最好有一定的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值