C++ lambda表达式

lambda

  • lambda 表达式简介
  • lambda 表达式的基本概念和基本用法
  • 函数,仿函数,lambda表达式

lambda 表达式简介

lambda表达式是C++11最重要也最常用的一个特性之一,其实在C#3.5中就引入了lambda,Java8中也引入了lambda表达式

lambda 来源于函数式编程的概念,也是现在编程语言的一个特点,有如下优点:

  • 声明式编程风格:就地匿名定义目标函数或函数对象,不需要额外写一个命名函数或者对象,以更直接的方式去写程序,好的可读性和可维护性
  • 简洁:不需要额外再写一个函数或者函数对象,避免了代码膨胀和功能分散,让开发者更加集中精力在手边的问题,同时也获取了更高的生产率
  • 在需要的时间和地点实现功能闭包,使程序更灵活

lambda 表达式的基本概念和基本用法

lambda表达式定义了一个匿名函数,并且可以捕获一定范围内的变量,lambda表达式的语法形式可简单归纳如下:

[caoture] (params) opt -> ret {body;};

其中:capture是捕获列表;params是参数表;opt是函数选项;ret是返回值类型;body是函数体,因此一个完整的lambda表达式看起来就像这样:

int main()
{
	auto f = [](int a) -> int {return a + 1; };
			//捕获列表        
	cout << f(1) << endl;
}
int main()
{
	auto f = [](int a) {return a; };
	//直接推导类型 可以省略 -> int
	auto f = [](int a) ->std::initializer_list<int> {return { a,1 }; };
	//auto f = [](int a)  {return { a,1 }; };  无法推到出
}

lambda 表达式可以通过获取列表捕获一定范围内的变量:

  • [] 不捕获任何变量
  • [&] 捕获外部作用域中所有变量,并作为引用在函数体中使用(按引用捕获)
  • [=] 捕获外部作用域中所有变量,并作为副本在函数体中使用(按值捕获)
  • [=,&foo] 按值捕获外部作用域中所有变量,并按引用获取foo变量
  • [bar] 按值捕获bar变量,同时不捕获其他变量
  • [this] 捕获当前类中的this指针,让lambda表达式拥有和当前类成员同样的访问权限,如果已经使用了&或者=,就默认添加此选项,捕获this的目的是可以在lambda中使用当前类的成员函数和成员变量
int g_max = 10; //全局变量 没有捕获的概念,可以直接使用
int add(int x, int y)
{
	return x + y;
}
int fun(int x)
{
	int sum = 10;
	int num = 20;
	auto f1 = [](int a) -> int {return a + g_max; };
	//[] 不捕获任何变量 ,sum num 都不能使用
	auto f2 = [&](int a) -> int
	 {
		x = a;
		sum += 10;
		num = a + x;
		return num;
	};
	//在此仿函数内,对sum num 有读写能力

	list<int> ar = { 12,23,34,45,56,67,78,89 };
	ar.sort([&](int a, int b)->bool {return a < b; });

	return 0;
}

int main()
{
	/*
	// error!!!
	auto f3 = [&](int a) -> int
	 {
		x = a;
		sum += 10;
		num = a + x;
		return num;
	};
	//只能捕获,存在于该函数内的局部变量与形参
	*/

	list<int> ar = { 34,23,45,67,12,56,78,89 };
	ar.sort([](int a, int b)->bool {return a > b; });
	//类似于仿函数,由大到小

	for (auto& x : ar)
	{
		cout << x << endl;
	}
}

从下面代码,捕获方式的不同可以看出,编译时就进行了捕获

// 可以类比为下面样子
class F1
{
	int& x;
public:
	F1(int& a) :x(a) {}
};
class F2
{
	int x;
public:
	F2(int a) :x(a) {}
	int operator()(int a)const
	{
		//x += 10;  error!!!
	}
};

int main()
{
	int x = 0;
	auto f1 = [&](int a) -> int 
	{
		x += 10;
		cout << x << endl;
		return x;
	};
	auto f2 = [=](int a)->int 
	{
		return x; 
		//编译时候就进行捕获
		//function的一个变种  捕获x,将int x = 0;进行赋值作为一个副本
		//不能进行 x+=10;某种意义上说是一个常量
	};

	x = 100;
	cout << f1(0) << endl;
	cout << f2(0) << endl;

	return 0;
}

在下面的代码中,x2 按值进行捕获,可以对a,和g_max进行捕获,并且对this指针进行了捕获,继而可以去使用value

int g_max = 10;
class Object
{
	int value;
public:
	Object(int x = 0) :value(x) {}

	void func(int a, int b)
	{
		auto x0 = []()->int {return g_max; };
		auto x1 = []()->int {return a; }; // errror

		auto x2 = [=]()->int
		{
			int x = value;
			return x + a + g_max;
		};
	}
}

虽然我们上面说了,按值捕获在某种意义上是一种常量,但是此处捕获的实际为this指针,所以可以对value值进行修改

		auto x3 = [=]() ->int
		{
			value += 10;
			int x = value;
			return x + a + g_max;
		};

mutable

class Object
{
	int value;
	mutable int num;
public:
	Object(int x = 0,int y = 0):value(x),num(y){}

	int fun()const
	{
		num += 10; //加了mutable关键字 可以修改
		return value + num; 
	}
};

int main()
{
	int a = 0;
	auto f1 = [=] {return a++; }; //error
	auto f2 = [=]() mutable {return a++; }; //可变的 
	//这里的a是上面a的一个副本
}

mutable关键字后,由于捕获为[=],所以lambda表达式中存放的是一个副本

class F1
{
	int _a;
public:
	F1(int x) :_a(x){}
	int operator()() const
	{
		_a += 10;
		return a;
	}
};
//下面f1 可以类比为上面,首先嗲东构造函数,初始化_a,然后调用括号运算符重载,最终得出20
int main()
{
	int a = 10;
	auto f1 = [=]()mutable->int
	{
		a += 10;
		return a;
	};
	a += 100;
	cout << "f1:" << f1() << endl;
	cout << "a:" << a << endl;
}

C++ lambda表达式_第1张图片

函数,仿函数,lambda表达式

template<class _BI, class _Fn>
void my_for_each(_BI _first, _BI _last, _Fn _func)
{
	cout << typeid(_Fn).name() << endl;
	for (; _first != _last; ++_first)
	{
		_func(*_first);
	}
}
void Print_Ar(int x)
{
	printf(" %d ", x);
}

struct Print
{
	void operator()(int x) const
	{
		printf(" %d ", x);
	}
};

int main()
{
	std::vector<int> ar = { 12,23,34,45,56,67,78 };
	my_for_each(ar.begin(), ar.end(), Print_Ar);
	cout << endl;
	my_for_each(ar.begin(), ar.end(), Print());
	cout << endl;
	
	my_for_each(ar.begin(), ar.end(), [](int a)->void {printf(" %d ", a); });


	return 0;
}

C++ lambda表达式_第2张图片
lambda表达式其实就是仿函数的语法糖

你可能感兴趣的:(C++,c++)