lambda表达式 mutable 仿函数

仿函数

template<class _Arg1,class _Arg2,class _Result>
struct my_binary_function
{
	typedef _Arg1 first_argument_type;
	typedef _Arg2 second_argument_type;
	typedef _Result result_type;
}
template <class _Tp>
struct my_plus : public my_binary_function<_Tp,_Tp,_Tp>
{
	_Tp operator()(const _Tp& _x,const _Tp& _y) const
	{
		return _x+_y;
	}
};
int main()
{
	int x=my_plus<int>()(12,23);//先是创建一个无名对象，然后传了俩个参数
}

lambda表达式

很像仿函数

类似于函数里面的函数

里面的变量不能改变，都是加了const的，加了mutable的变量，后面即使加了const也是可以改变的

里面的变量是重新拷贝出来的和外面的变量不一样

全局变量不需要捕获

[] 不捕获变量

[=]全部捕获按照值捕获

[&]以引用的方式捕获，他的变量是可以改变的，因为以你引用的底层就是指针

[=,&a]a是引用捕获，
[this]

uto x0=[]()->int {return g_max;}

函数中this指针可以捕获，但是不可以捕获this指针所指之物

this指针不可变，但是this指针所指之物可以变

int main()
{
	auto f=[](int a,int b)->int {return a+b;};
	int x=f(12,23);
	cout<<x<<endl;
}

int fun()
{
	Object objx(10);
	auto f1=[&]()->void
	{
		objx.Value()=100;
	};
	auto f2=[=]()->int
	{
		int a=objx.Value();//objx是重新构造的
		return a;
	};
	int x=f2;

mutable

class Object
{
	int value;
	mutable int num;//有了这个关键字，即使fun方法加了const，num也是可以修改
public:
	Object(int x=0,int y=0)value{x},num{y}{}
	int fun()const
	{
		int a=10;
		a+=10;
		this->num+=10;
		return num;
	}
};

template<class _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);});//lambda表达式
	return 0;
}