C++起始之路——C++11（下）

💁‍♂️个人主页：进击的荆棘

👇作者其它专栏：

《数据结构与算法》《算法》《C++起始之路》

---

1.C++11的发展历史

2.列表初始化

3.右值引用和移动语义

4.可变参数模板

5.新的类功能

6.STL中一些变化

7.lambda

---

4.可变参数模板

4.1基本语法及原理

●C++11支持可变参数模板，即支持可变数量参数的函数模板和类模板，可变数目的参数被称为参数包，存在两种参数包：模板参数包，表示零或多个参数模板；函数参数包：表示零或多个函数参数。

●template<class ...Args> void Func(Args...args) {}

●template<class ...Args> void Func(Args&...args) {}

●template<class ...Args> void Func(Args&&...args) {}

●用省略号来指出一个模板参数或函数参数表示一个包，在模板参数列表中，class...或typename...指出接下来的参数表示零或多个类型列表；在函数参数列表中，类型名后面跟...指出接下来表示零或多个形参对象列表；函数参数包可以用左值引用或右值引用表示，跟前面普通模板一样，每个参数实例化时遵循引用折叠规则。

●可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。

●这里可以用sizeof...运算符去计算参数包中参数的个数。

template<class ...Args>
void Print(Args&&... args){
    cout<<sizeof...(args)<<endl;
}
int main(){
    double x=2.2;
    Print();        //包里有0个参数
    Print(1);       //包里有1个参数
    Print(1,string("xxxxx"));       //包里有2个参数
    Print(1.1,string("xxxxx"),x);   //包里有3个参数    
    return 0;
}

//原理1：编译本质这里会结合折叠规则实例化出以下四个函数
void Print();
void Print(int&& arg1);
void Print(int&& arg1,string&& arg2);
void Print(double&& arg1,string&& arg2,double& arg3);

//原理2：更本质去看没有可变参数模板，实现出这样的多个函数模板才能支持这里的功能，有了可变参数模板，就会进一步被解放，它是
//      类型泛化基础上叠加数量变化，让泛型编程更灵活。
void Print();

template <class T1>
void Print(T1&& arg1);

template<class T1,class T2>
void Print(T1&& arg1,T2&& arg2);

template <class T1,class T2,class T3>
void Print(T1&& arg1,T2&& arg2,T3&& arg3);

4.2包扩展

●对于一个参数包，除了能计算它的参数个数，我们能做的唯一的事情就是扩展它，当扩展一个包时，还需提供用于扩展元素的模式，扩展一个包就是将它分解为构成的元素，对于每个元素应用模式，获得扩展后的列表。通过在模式的右边放一个省略号（...）来触发扩展操作。底层的实现细节如图1所示。

●C++还支持更复杂的包扩展，直接将参数包依次展开作为实参给一个函数去处理。

//可变模板参数
//参数类型可变
//参数个数可变
//打印参数包内容
//template<class ...Args>
//void Print(Args... args)
//{
    //可变参数模板编译时解析
    //下面时运行获取和解析，所以不支持这样用
    // cout<<sizeof...(args)<<endl;
    // for(size_t i=0;i<sizeof...(args);i++){
    //     cout<<args[i]<<" ";
    // }
//     cout<<endl;
//}

void ShowList(){
    //编译时递归的终止条件，参数包是0个时，直接匹配这个函数
    cout<<endl;
}

template<class T,class ...Args>
void ShowList(T x,Args... args){
    cout<<x<<" ";
    //args是N个参数的参数包
    //调用ShowList，参数包的第一个传给x，剩下N-1传给第二个参数包
    ShowList(args...);
} 

//编译时递归推导解析参数
template<class ...Args>
void Print(Args... args){
    ShowList(args...);
}

int main(){
    Print();
    Print(1);
    Print(1,string("xxxxxx"));
    Print(1,string("xxxxxx"),2.2);

    return 0;
}

//template<class T,class ...Args>
//void ShowList(T x,Args... args){
//  cout<<x<<" ";
//  Print(args...);
//}

//Print(1,string("xxxxxx"),2.2);调用时
//本质编译器将可变参数模板通过模式的包扩展，编译器推导的以下三个重载函数
//void ShowList(double x){
//  cout<<x<<" ";
//  ShowList();
//}
//void ShowList(string x,double z){
//  cout<<x<<" ";
//  ShowList(z);
//}
//void ShowList(int x,string y,double z){
//  cout<<x<<" ";
//  ShowList(y,z);
//}

//void Print(int x,string y,double z){
//  ShowList(x,y,z);
//}

template<class T>
const T& GetArg(const T& x){
    cout<<x<<" ";
    return x;
}

template<class ...Args>
void Arguments(Args... args) {}

template<class ...Args>
void Print(Args... args){
    //注意GetArg必须返回获得到的对象，这样才能组成参数包给Arguments
    Arguments(GetArg(args)...);
}

//本质可以理解为编译器编译时，包的扩展模式
//将上面的函数模板扩展实例化为下面的函数
//void Print(int x,string y,double z){
//  Arguments(GetArg(x),GetArg(y),GetArg(z));
//}
int main(){
    Print(1,string("xxxxxx"),2.2);

    return 0;
}

4.3emplace系列接口

●template<class... Args> void emplace_back(Args&& ...args);

●template<class... Args> iterator emplace(const_iterator postion,Args&& ...args);

●C++11以后STL容器新增了emplace系列的接口，emplace系列的接口均为模板可变参数，功能上兼容push和insert系列，但是emplace还支持新玩法，假设容器为container<T>，emplace还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。

●emplace_back总体而言更高效，推荐以后使用emplace系列代替insert和push系列。

●第二个程序中模拟实现了list的emplace和emplace_back接口，这里把参数包不断往下传递，最终在节点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前面说的emplace支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。

●传递参数包过程中，若是Args&&... args的参数包，要用完美转发参数包，方式如下std::forward<Args>(args)... ，否则编译时包扩展后右值引用变量表达式就变成了左值。

namespace achieve{
    class string{
    public:
      typedef char *iterator;
      typedef const char* const_iterator;
      iterator begin(){
        return _str;
      }
      //迭代器都是左闭右开的  
      iterator end(){
        return _str+_size;
      }
      const_iterator begin() const{
        return _str;
      }
      const_iterator end() const{
        return _str+_size;
      }
      /*string()
        :_str(new char[1]{'\0'})
        ,_size(0)
        ,_capacity(0)
       {}*/
      //短小频繁调用的函数，可直接定义到类中，默认为inline
      string(const char* str="")
        :_size(strlen(str))
        ,_capacity(_size)
      {
        cout<<"string(const char* str="")--构造"<<endl;
        _str=new char[_capacity+1];//存放\0
        strcpy(_str,str);
      }
      //拷贝构造
      string(const string& s){
        cout<<"string(const string& s)--拷贝构造"<<endl;
        reserve(s._capacity);
        for(auto ch:s)
            push_back(ch);
      }
      //下面为现代写法
      void swap(string& s){
        std::swap(s._str,_str);
        std::swap(s._size,_size);
        std::swap(s._capacity,_capacity);
      }
      //移动构造
      string(string&& s){
        cout<<"string(string&& s)--移动构造"<<endl;
        swap(s);
      }
      //运算符重载赋值
      string& operator=(const string& s){
        cout<<"string& operator=(const string& s)--拷贝赋值"<<endl;
        if(this!=&s){
          _str[0]='\0';
          _size=0;
          reserve(s._capacity);
          for(auto ch:s)
            push_back(ch);
        }
        return *this;
      }
      //移动赋值
      string& operator=(string&& s){
        cout<<"string& operator=(string&& s)--移动赋值"<<endl;
        swap(s);
        return *this;
      }
      ~string(){
        delete[] _str;
        _str=nullptr;
      }
      char &operator[](size_t pos){
        assert(pos<_size);
        return _str[pos];
      }
      void reserve(size_t n){
        if(n>_capacity){
            char* tmp=new char[n+1];
            if(_str){
                strcpy(tmp,_str);
                delete[] _str;
            }
            _str=tmp;
            _capacity=n;
        }
      }
      void push_back(char ch){
        if(_size>=_capacity){
            if(_size>=_capacity){
                size_t newcapacity=_capacity==0?4:_capacity*2;
                reserve(newcapacity);
            }
        }
        _str[_size]=ch;
        ++_size;
        _str[_size]='\0';
      }
      string& operator+=(char ch){
        push_back(ch);
        return *this;
      }
      const char* c_str() const{
        return _str;
      }
      size_t size() const{
        return _size;
      }
    private:
        char *_str=new char('\0');
        size_t _size=0;
        size_t _capacity=0;
    };
}

//emplace_back总体而言更高效，推荐以后使用emplace系列代替insert和push系列
int main(){
    list<achieve::string> lt;
    //传左值，跟push_back一样，走拷贝构造
    achieve::string s1("11111111");
    lt.emplace_back(s1);
    cout<<"*************************"<<endl;

    //右值，跟push_back一样，走移动构造
    lt.emplace_back(move(s1));
    cout<<"*************************"<<endl;

    //直接把构造string参数包往下传，直接用string参数包构造string
    //这里达到的效果是push_back做不到的
    lt.emplace_back("1111111111111");
    cout<<"*************************"<<endl;

    list<pair<achieve::string,int>> lt1;
    //跟push_back一样
    //构造pair+拷贝/移动构造pair到list的节点中data上
    pair<achieve::string,int> kv("苹果",1);
    lt1.emplace_back(kv);
    cout<<"*************************"<<endl;

    //跟push_back一样
    lt1.emplace_back(move(kv));
    cout<<"*************************"<<endl;

    //直接把构造pair参数包往下传，直接用pair参数包构造pair
    //这里达到的效果是push_back做不到的
    lt1.emplace_back("苹果",1);
    cout<<"*************************"<<endl;
    
    return 0;
}

namespace Achieve{
  template<class T>
  struct list_node{
    T _data;
    list_node<T>* _next;
    list_node<T>* _prev;
    list_node(T&& data)
      :_data(move(data))
      ,_next(nullptr)
      ,_prev(nullptr)
    {}

    template<class ...Args>
    list_node(Args&&... args)
        :_data(std::forward<Args>(args)...)
        ,_next(nullptr)
        ,_prev(nullptr)
    {}
  };
  template<class T,class Ref,class Ptr>
  struct list_iterator{
    typedef list_node<T> Node;
    typedef list_iterator<T,Ref,Ptr> Self;
    Node* _node;
    list_iterator(Node* node)
      :_node(node)
    {}
    Ref operator*(){
      return _node->_data;
    }
    //前置++
    Self& operator++(){
      _node=_node->_next;
      return *this;
    }
    Self& operator--(){
      _node=_node->_prev;
      return *this;
    }
    bool operator!=(const Self& s){
      return _node!=s._node;
    }
  };
  template<class T>
  class list{
    typedef list_node<T> Node;
  public:
    typedef list_iterator<T,T&,T*> iterator;
    typedef list_iterator<T,const T&,const T*> const_iterator;
    iterator begin(){
        return iterator(_head->_next);
    }
    iterator end(){
        return iterator(_head);
    }
    void empty_init(){
      _head=new Node();
      _head->_next=_head;
      _head->_prev=_head;
    }
    list(){
      empty_init();
    }
    void push_back(const T& x){
      insert(end(),x);
    }
    void push_back(T&& x){
        insert(end(),move(x));
    }
    iterator insert(iterator pos,const T& val){
      Node* cur=pos._node;
      Node* prev=cur->_prev;
      Node* newnode=new Node(val);

      newnode->_next=cur;
      newnode->_prev=prev;
      cur->_prev=newnode;
      prev->_next=newnode;

      return iterator(newnode);
    }
    iterator insert(iterator pos,T&& x){
        Node* cur=pos._node;
        Node* newnode=new Node(move(x));
        Node* prev=cur->_prev;

        prev->_next=newnode;
        newnode->_prev=prev;
        newnode->_next=cur;
        cur->_prev=newnode;

        return iterator(newnode);
    }
    template<class... Args>
    void emplace_back(Args&&... args){
        insert(end(),std::forward<Args>(args)...);
    }
    //原理：本质编译器根据可变参数模板生成对应参数的函数
    /*void empalce_back(string& s){
        insert(end(),std::forward<string>(s));
    }
    void empalce_back(string&& s){
        insert(end(),std::forward<string>(s));
    }
    void empalce_back(const char* s){
        insert(end(),std::forward<const char*>(s));
    }*/
   template<class... Args>
   iterator insert(iterator pos,Args&&... args){
    Node* cur=pos._node;
    Node* newnode=new Node(std::forward<Args>(args)...);
    Node* prev=cur->_prev;

    prev->_next=newnode;
    newnode->_prev=prev;
    newnode->_next=cur;
    cur->_prev=newnode;

    return iterator(newnode);
   }
  private:
    Node* _head;
  };
}


//emplace_back总体而言更高效，推荐以后使用emplace系列代替insert和push系列
int main(){
    Achieve::list<Achieve::string> lt;
    //传左值，跟push_back一样，走拷贝构造
    Achieve::string s1("11111111");
    lt.emplace_back(s1);
    cout<<"*************************"<<endl;

    //右值，跟push_back一样，走移动构造
    lt.emplace_back(move(s1));
    cout<<"*************************"<<endl;

    //直接把构造string参数包往下传，直接用string参数包构造string
    //这里达到的效果是push_back做不到的
    lt.emplace_back("1111111111111");
    cout<<"*************************"<<endl;

    Achieve::list<pair<Achieve::string,int>> lt1;
    //跟push_back一样
    //构造pair+拷贝/移动构造pair到list的节点中data上
    pair<Achieve::string,int> kv("苹果",1);
    lt1.emplace_back(kv);
    cout<<"*************************"<<endl;

    //跟push_back一样
    lt1.emplace_back(move(kv));
    cout<<"*************************"<<endl;

    //直接把构造pair参数包往下传，直接用pair参数包构造pair
    //这里达到的效果是push_back做不到的
    lt1.emplace_back("苹果",1);
    cout<<"*************************"<<endl;

    return 0;
}

5.新的类功能

5.1默认的移动构造和移动赋值

●原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址重载/const取地址重载，最重要的是前4个，后两个用处不大，默认成员函数就是不写编译器会生成一个默认的。C++11新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。

●若没有自己实现移动构造函数，且没有实现析构函数、拷贝构造函数、拷贝赋值重载中的任意一个。则编译器就会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会逐行逐成员按自己拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，若实现了就调用移动构造，没有实现就调用拷贝构造。

●若没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会逐行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，若实现了就调用移动赋值，没有实现就调用拷贝赋值。（默认移动赋值跟上面移动构造完全类似）

●若提供了移动构造或移动赋值，编译器就不会自动生成拷贝构造和拷贝赋值。

class Person{
public:
    Person(const char* name="",int age=0)
        :_name(name)
        ,_age(age)
    {}
    /*Person(const Person& p)
        :_name(p._name)
        ,_age(p._age)
    {}
    */
    /*Person& operator=(const Person& p){
        if(this!=&p){
            _name=p._name;
            _age=p._age;
        }
        return *this;
    }*/
   /*~Person()
   {}*/
private:
    Achieve::string _name;
    int _age;
};

int main(){
    Person s1;
    Person s2=s1;
    Person s3=std::move(s1);
    Person s4;
    s4=std::move(s2);

    return 0;
}

5.2成员变量声明时给缺省值

成员变量声明时给缺省值是给初始化列表用的，若没有显示在初始化列表初始化，就会在初始化列表用这个缺省值初始化。

5.3default和delete

●C++11可以让我们更好的控制要使用的默认函数。假设要使用用某个默认的函数，但是因为一些原因这个函数没有默认生成。如：提供了拷贝构造，就不会生成移动构造了，那我们就可以使用default关键字显示指定移动构造生成。

●若能想要限制某些默认函数的生成，在C++98中，是该函数设置称private，并且只声明不定义，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

class Person{
public:
    Person(const char* name="",int age=0)
        :_name(name)
        ,_age(age)
    {}
    Person(const Person& p)
        :_name(p._name)
        ,_age(p._age)
    {}
    Person(Person&& p)=default;
private:
    Achieve::string _name;
    int _age;
};

int main(){
    Person s1;
    Person s2=s1;
    Person s3=std::move(s1);

    return 0;
}

5.4final与override

在继承和多态中，已经介绍过。

6.STL中一些变化

●下图1圈起来的就是STL中的新容器，但是实际最有用的是unordered_map和unordered_set。

●STL中容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列接口和移动构造和移动赋值，还有initializer_list版本的构造等，还有一些无关痛痒的如cbegin/cend等需要时查看文档即可。

●容器的范围for遍历。

7.lambda

7.1lambda表达式语法

●lambda表达式本质是一个匿名函数对象，跟普通函数不同的是它可以定义在函数内部。lambda表达式语法使用层而言没有类型，所有一般是用auto或模板参数定义的对象去接收lambda对象。

●lambda表达式的格式：[capture-list] (parameters)-> return type { function body}

●[capture-list]：捕捉列表，该列表总是出现lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用，捕捉列表可以传值和传引用捕捉。捕捉列表为空也不能省略。

●(parameters)：参数列表，与普通函数的参数列表功能类似，若不需要参数传递，则可以连同()一起省略。

●->return type：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。一般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

●{function body}：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略。

int main(){
    //一个简单的lambda语法
    auto add1=[](int x,int y)->int {return x+y;};
    cout<<add1(1,2)<<endl;
    //1.捕捉为空也不能省略
    //2.参数为空可以省略
    //3.返回值可以省略，可以通过返回对象自动推导
    //4.函数体不能省略
    auto func1=[]{
        cout<<"hello world"<<endl;
        return 0;
    };

    func1();

    int a=0,b=1;
    auto swap1=[](int& x,int& y){
        int tmp=x;
        x=y;
        y=tmp;
    };
    swap1(a,b);
    cout<<a<<":"<<b<<endl;

    return 0;
}

7.2捕捉列表

●lambda表达式中默认只能用lambda函数体和参数中的变量，若想用外层作用域中的变量就需要进行捕捉。

●第一种捕捉方式是在捕捉列表中显示的传值和传引用捕捉，捕捉的多个变量用逗号分割。[x,y,&z]表示x和y值捕捉，z引用捕捉。

●第二种捕捉方式是在捕捉列表中隐式捕捉，在捕捉列表写一个=表示隐式捕捉，在捕捉列表写一个&表示隐式引用捕捉，这样在lambda表达式中用了那些变量，编译器就会自动捕捉那些变量。

●第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显示捕捉。[=,&x]表示其它变量隐式值捕捉，x引用捕捉；[&,x,y]表示其它变量引用捕捉，x和y捕捉。当使用混合捕捉时，第一个元素必须是&或=，并且&混和捕捉时，后面的捕捉变量必须是值捕捉，同理=混合捕捉时，后面的捕捉变量必须是引用捕捉。

●**lambda表达式若在函数局部域中，则可以捕捉lambda位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉，lambda表达式中可以直接使用。**这也意味着lambda表达式若定义在全局位置，捕捉列表必须为空。

●默认情况下，lambda捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改，mutable加在参数列表后面可以取消其常量性，也就是说使用该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使用该修饰符后，参数列表不可省略（即使参数为空）。

int x=0;
//捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量
auto func1=[](){
    x++;
};

int main(){
    //只能用当前lambda局部域和捕捉的对象和全局对象
    int a=0,b=1,c=2,d=3;
    auto func1=[a,&b]{
        //值捕捉的变量不能修改，引用捕捉的变量可以修改
        //a++;
        b++;
        int ret=a+b;
        return ret;
    };
    cout<<func1()<<endl;

    //隐式值捕捉
    //用了哪些变量就捕捉哪些变量
    auto func2=[=]{
        int ret=a+b+c;
        return ret;
    };
    cout<<func2()<<endl;
    
    //隐式引用捕捉
    //用了哪些变量就捕捉哪些变量
    auto func3=[&]{
        a++;
        c++;
        d++;
    };
    func3();
    cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;

    //混合捕捉1
    auto func4=[&,a,b]{
        //a++;
        //b++;
        c++;
        d++;
        return a+b+c+d;
    };
    func4();
    cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;

    //混合捕捉2
    auto func5=[=,&a,&b]{
        a++;
        b++;
        //c++;
        //d++;
        return a+b+c+d;
    };
    func5();
    cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;

    //局部的静态和全局的变量不能捕捉，也不需要捕捉
    static int m=0;
    auto func6=[]{
        int ret=x+m;
        return ret;
    };

    //传值捕捉的本质是一种拷贝，并且被const修饰了
    //mutable相当于去掉const属性，可以修改了
    //但是修改了不会影响外面被捕捉的值，因为是一种拷贝
    auto func7=[=]()mutable{
        a++;
        b++;
        c++;
        d++;
        return a+b+c+d;
    };
    cout<<func7()<<endl;
    cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;
    
    return 0;
}

7.3lambda的应用

●在学习lambda表达式之前，我们的使用的可调用对象只有函数指针和仿函数对象，函数指针的类型定义起来比较麻烦，仿函数要定义一个类，相对会比较麻烦。使用lambda去定义可调用对象，既简单又方便。

●lambda在很多其它地方用起来也很好用。如：线程中定义线程的执行函数逻辑，智能指针中定制删除器等，lambda的应用还是很广泛。

struct Goods{
    string _name;
    double _price;
    int _evaluate;

    Goods(const char* str,double price,int evaluate)
        :_name(str)
        ,_price(price)
        ,_evaluate(evaluate)
    {}
};

struct ComparePriceLess{
    bool operator()(const Goods& gl,const Goods& gr){
        return gl._price<gr._price;
    }
};

struct ComparePriceGreater{
    bool operator()(const Goods& gl,const Goods& gr){
        return gl._price>gr._price;
    }
};

int main(){
    vector<Goods> v={{"苹果",2.1,5},{"香蕉",4.2,5},{"香瓜",3.3,4},{"橙子",4.1,4}};
    //类似这样的场景，实现仿函数对象或函数指针支持商品中不同项的比较，
    //还是相对比较麻烦的，此时用lambda就很好
    sort(v.begin(),v.end(),ComparePriceLess());
    sort(v.begin(),v.end(),ComparePriceGreater());

    sort(v.begin(),v.end(),[](const Goods& g1,const Goods& g2){
        return g1._price<g2._price;
    });
    sort(v.begin(),v.end(),[](const Goods& g1,const Goods& g2){
        return g1._price>g2._price;
    });
    sort(v.begin(),v.end(),[](const Goods& g1,const Goods& g2){
        return g1._evaluate<g2._evaluate;
    });
    sort(v.begin(),v.end(),[](const Goods& g1,const Goods& g2){
        return g1._evaluate>g2._evaluate;
    });
    
    return 0;
}

7.4lambda的原理

●lambda的原理和范围for很像，编译后从汇编指令层的角度看，压根就没有lambda和范围for这样的东西。范围for底层是迭代器，而lambda底层是仿函数对象，也就是说写了一个lambda以后，编译器会生成一个对应的仿函数的类。

●仿函数的类名是编译按一定规则生成的，保证不同的lambda生成的类名不同，lambda参数/返回类型/函数体就是仿函数operator（）的参数/返会类型/函数体，lambda的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是lambda类1构造函数的实参，对于隐式捕捉而言，编译器要看使用哪些就传哪些对象。

●上面的原理，可以通过汇编层了解一下，下面第二段汇编层代码印证了上面的原理。

class Rate{
public:
    Rate(double rate)
        :_rate(rate)
    {}

    double operator()(double money,int year){
        return money*_rate*year;
    }
private:
    double _rate;
};

int main(){
    double rate=0.49;

    //lambda
    auto r2=[rate](double money,int year){
        return money*rate*year;
    };

    //函数对象
    Rate r1(rate);
    r1(10000,2);

    r2(10000,2);
    auto func1=[]{
        cout<<"hello world"<<endl;
    };
    func1();

    return 0;
}

//lambda
r2=[rate](double money,int year){
    return money*rate*year;
};
//捕捉列表的rate，可以看到作为lambda_1类构造函数的参数传递了，这样要拿起初始化成员变量

//下面operator（）中才能使用
00D8295C    lea    eax[rate]
00D8295F    push   eax
00D82960    lea    eax,[r2]
00D82963    call   `main'::`2'::<lambda_1>::<lambda_1> (0D81F80h)

            //函数对象
        Rate r1(rate);
00D82968    sub    esp,8
00D8296B    movsd  xmm0,mmword ptr[rate]
00D82970    movsd  mmword ptr [esp],xmm0
00D82975    lea    ecx,[r1]
00D82978    call   Rate::Rate (0D81438h)
        r1(10000,2);
00D8297D    push   2
00D82982    sub    esp,8
00D82982    movsd  xmm0,mmword ptr [__real@40c3880000000000 (0D89B50h)]
00D8298A    movsd  mmword ptr [esp],xmm0
00D8298F    lea    ecx,[r1]
00D82992    call   Rate::operator() (0D81212h)

//汇编层可以看到r2 lambda对象调用本质还是调用operator（），类型是lambda_1，这个类型名的
//规则是编译器自己定制的，保证不同的lambda不冲突
        r2(10000,2);
00D82999    push   2
00D8299B    sub    esp,8
00D8299E    movsd  xmm0,mmword ptr [__real@403880000000000 (0D89B50h)]
00D829A6    movsd  mmword ptr [esp],xmm0
00D829AB    lea    ecx,[r2]
00D829AE    call   `main'::`2'::<lambda_1>::operator() (0D824C0h)