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;
}