写在前面

1、本文内容
cpp lambda表达式笔记
2、转载请注明出处：
https://blog.csdn.net/qq_41102371/article/details/124122408

void lambda_prac() {
	{
		//auto 自动推导返回类型，[]捕获参数，()是传入参数
		auto x = [](int val) 
		{
			return val > 3;
		};
		std::cout << x(5) << std::endl;//1(true)
	}
	//指定类型
	{
		//float类型，返回类型double和float 不同，无法自动推导，因此使用->float指定
		auto x = [](int val) ->float
		{
			if (val > 3) {
				return 3.0;//double类型
			
			}
			else {
				return 1.5f;
			}
		};
		std::cout << x(5) << std::endl;
	
	}

	//捕获外部变量[y]，捕获使用的是值捕获，会在构造的类里面用捕获值去初始化另一个y,值捕获需要加mutable
	{
		int y = 10;
		auto x = [y](int val) mutable
		{
			++y;
			return val > y;

		};

		std::cout << x(5) << std::endl;
		std::cout << y << std::endl;//10,++y只会改变lambda表达式类内部的y,不会改变外部的y
	}

	//需要在内部修改捕获变量时，使用引用捕获[&y]，引用捕获不用加mutable
	{
		int y = 10;
		auto x = [&y](int val)
		{
			++y;
			return val > y;

		};

		std::cout << x(5) << std::endl;
		std::cout << y << std::endl;//11
	}
	//静态或全局变量不用捕获
	{
		static int z = 10;
		auto x = [](int val)
		{
			return val > z;

		};
		std::cout << x(5) << std::endl;
	}

	//混合捕获
	{
		int y = 10;
		int z = 3;
		auto x = [&y,z](int val)
		{
			++y;
			return val > z;
		};
		std::cout << x(5) << std::endl;
		std::cout << y << std::endl;//11
	}


	//自动捕获,表达式中使用了局部自动对象，这些对象没有显式地出现在捕获列表，使用[=]进行值捕获
	{
		int y = 10;
		int z = 3;
		auto x = [=](int val) mutable
		{
			++y;
			return val > z;
		};
		std::cout << x(5) << std::endl;
		std::cout << y << std::endl;//10
	}

	//同理，引用捕获
	{
		int y = 10;
		int z = 3;
		auto x = [&](int val)
		{
			++y;
			return val > z;
		};
		std::cout << x(5) << std::endl;
		std::cout << y << std::endl;//11
	}

	//[&,z]说明局部自动对象都是采用引用捕获的方式，但z例外，只采用值捕获
	//[=,&y]相反
	{
		int y = 10;
		int z = 3;
		auto x = [&,z](int val)
		{
			++y;
			return val > z;
		};
		std::cout << x(5) << std::endl;
		std::cout << y << std::endl;//11
	}

	//*this捕获

	{
		struct Str {
			auto fun() {
				int val = 3;
				auto lam = [val, this]()
				{
					return val > x;
				};
				return lam();
			}
			int x;//此时x不是局部自动对象，不能直接捕获，要使用this

		};
		Str s;
		s.fun();
	
	}

	//初始化捕获,
	{
		int x = 3;
		auto lam = [y = x](int val) {

			return val > y;
		};
	}

	//初始化捕获,
	{
		int x = 3;
		int y = 10;
		auto lam = [z=x+y](int val) {

			return val > z;
		};
	}

	//*this捕获会复制整个对象，更安全，但耗资源

	//constexpr 在编译期确定
	{
		auto lam = [](int val) constexpr
		{
			return val + 1;
		};
		constexpr int val = lam(100);//编译期确定val=101
	}
	//constexpr定义的函数既能在编译期使用也能在运行期调用，consteval只能在编译期调用 c++20
	{
		auto lam = [](int val) consteval
		{
			return val + 1;
		};
		constexpr int val = lam(100);//编译期确定val=101
	}
	
	//模板形参 c++20
	{
		auto lam = []<typename T>(T val) 
		{
			return val + 1;
		};
	
	}
}