STL容器中的empalce相关接口函数

emplace_back是可以不传参的，那么默认用户的就是匿名构造，传入的值就是0。

那么emplace_back的意义在哪里呢？

#include<iostream>
#include<vector>
using namespace std;
int main()
{
  vector<pair<int, string>>arr;
  arr.emplace_back(1, "xxx");//这里可以这样初始化(直接构造),push_back只能构造一个对象去传，当然emplace_back也可以构造一个对象传
  return 0;
}

其实就是一种优化，如果传入的是右值编译器可以直接优化成直接构造（移动构造或者是移动赋值都省下了），不需要任何拷贝构造或者是移动构造（如果是左值还是构造+深拷贝）。

lambda表达式

为什么要有lambda表达式

这个和仿函数有些类似。

举个例子，如果定义水果类，创建多个水果对象，那么他们分别有名字，价格，评价等等属性，如果想通过sort函数来实现对于不同对象的排序就要写很多个仿函数，非常的麻烦。

#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std; 
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 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
  sort(v.begin(), v.end(), ComparePriceLess());
  sort(v.begin(), v.end(), ComparePriceGreater());
  return 0;
}

那么这个时候lambda表达式就可以上场了。

#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std; 
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 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
  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; });//按照评价排序
  return 0;
}

这是按照价格排序的结果：

这是按照评价排序：

lambda表达式的格式

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }

lambda表达式各部分说明

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。

mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。

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

{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为

空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

#include<iostream>
using namespace std;
int main()
{
  //其实lambda就是要给可调用的对象
  auto compare = [](int x, int y) {return x > y; };//这个类型编译器认识，但是我们不认识
  cout << compare(1, 2) << endl;
  return 0;
}

那么，在外部定义的变量能在lambda表达式中使用吗？

#include<iostream>
using namespace std;
int main()
{
  int a = 10;
  int b = 20;
  auto add1 = []() { return a + b; };
  return 0;
}

这里是不可以的，因为是两个不同的作用域，这个时候需要捕捉这两个变量才可以使用。

auto add1 = [a, b]() { return a + b; };

这个时候编译就通过了。

那么如果想交换两个变量呢？

#include<iostream>
using namespace std;
int main()
{
  int a = 10;
  int b = 20;
  auto swap1 = [a, b]()
  {
    int c = a;
    a = b;
    b = c;
  };
  return 0;
}

这里是不允许的，如果想修改要加mutable。

auto swap1 = [a, b]()mutable
  {
    int c = a;
    a = b;
    b = c;
  };

但是外部的a和b并没有发生改变，也就是说捕捉的对象是传值拷贝，加了一个const的变量，mutable只是让他们变成非const属性的值。

如果想改变就要这样：

#include<iostream>
using namespace std;
int main()
{
  int a = 10;
  int b = 20;
  auto swap1 = [&a, &b]()//这里虽然是外部a和b的别名，但是不能修改a和b的名字，不然就不能捕捉了
  {
    int c = a;
    a = b;
    b = c;
  };
  return 0;
}

这里也无法在捕捉列表取地址。

在捕捉列表里面可以用=就是捕捉父作用域向上的变量，&是捕捉父作用域向上的变量别名。（向上就是在捕捉列表语句前面的所有变量）

#include<iostream>
using namespace std;
int main()
{
  int a = 10;
  int b = 20;
  auto add1 = [=]() { return a + b; };
  auto swap1 = [&]()
  {
    int c = a;
    a = b;
    b = c;
  };
  return 0;
}

注意：这些可以进行混合捕捉，比如对父作用域向上的变量进行传值捕捉，对于某一个或者是某些进行引用捕捉。

lambda的底层

#include<iostream>
using namespace std;
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;
  Rate r1(rate);
  r1(10000, 2);
  // lamber
  auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
  r2(10000, 2);
  return 0;
}

第一个是仿函数的反汇编，第二个是lambda表达式的反汇编，也就是说本质都是一样的调用仿函数。

并且lambda表达式的类型名字也很繁琐。

包装器

function包装器

function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

#include<iostream>
using namespace std;
template<class F, class T>
T useF(F f, T x)
{
  static int count = 0;
  cout << "count:" << ++count << endl;
  cout << "count:" << &count << endl;
  return f(x);
}
double f(double i)
{
  return i / 2;
}
struct Functor
{
  double operator()(double d)
  {
    return d / 3;
  }
};
int main()
{
  // 函数名
  cout << useF(f, 11.11) << endl;
  // 函数对象
  cout << useF(Functor(), 11.11) << endl;
  // lamber表达式
  cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
  return 0;
}

这里实例化的三分不同的函数，有没有什么办法让他不生成这么多的函数。

#include<iostream>
#include<functional>
using namespace std;
int f(int a, int b)
{
  return a + b;
}
struct Functor
{
public:
  int operator() (int a, int b)
  {
    return a + b;
  }
};
int main()
{
  function<int(int, int)> f1;//第一个int是返回值，括号里面的是参数
  f1 = f;//封装到f1中
  cout << f1(1, 2) << endl;
  function<int(int, int)> f2(f);//这种方法也可以将f封装到f2中
  cout << f2(1, 2) << endl;
  function<int(int, int)> f3 = Functor();
  cout << f3(1, 2) << endl;
  /*function<int(int, int)> f4(Functor());//这里不可以，因为编译器会识别成为函数指针
  cout << f4(1, 2) << endl;*/
  function<int(int, int)> f5 = [](const int a, const int b){return a + b; };
  cout << f5(1, 2) << endl;
}

类中的成员函数也是可以包装的，但是要注意：

#include<iostream>
#include<functional>
using namespace std;
class Plus
{
public:
  static int plusi(int a, int b)
  {
    return a + b;
  }
  int plusd(int a, int b)
  {
    return a + b;
  }
};
int main()
{
  //这里存入的是函数指针
  function<int(int, int)> f1 = &Plus::plusi;//静态成员函数可以不加&
  cout << f1(1, 2) << endl;
  function<int(Plus, int, int)> f2 = &Plus::plusd;//非静态成员函数必须加&，这里还要加一个参数，因为传参还有一个this指针
  cout << f2(Plus(), 1, 2) << endl;//这里是传进去一个Plus类型的对象，其实就是利用这个对象调用该成员函数而已
}

其实包装器就是对于可调用对象类型的大统一。

那么使用的场景呢？

力扣：逆波兰表达式

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> opMap=
        {
            {"+",[](int x, int y){return x+y;}},
            {"-",[](int x, int y){return x-y;}},
            {"/",[](int x, int y){return x/y;}},
            {"*",[](int x, int y){return x*y;}}
        };//这里就是统一了类型
        for(auto& e:tokens)//在map中查找符号
        {
            if(opMap.count(e))
            {
                int a = st.top();
                st.pop();
                int b = st.top();
                st.pop();
                st.push(opMap[e](b, a));//找到之后就将栈中的两个值通过map中储存的包装器中的lamber表达式进行运算，这里要注意数的顺序，先去取出来的在左边，后取出来的在右边
            }
            else
            {
                st.push(stoi(e));
            }
        }
        return st.top();
    }
};

bind

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

举例：

#include<iostream>
#include <functional>
using namespace std;
int Plus(int a, int b)
{
  return a - b;
}
int main()
{
  //表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
  function<int(int, int)> func1 = bind(Plus, placeholders::_1,placeholders::_2);//placeholders是占位对象
  cout << func1(1, 2) << endl;
  //_1代表本来的第一个参数，_2代表本来的第二个参数
  //这里调参数
  function<int(int, int)> func3 = bind(Plus, placeholders::_2, placeholders::_1);
  cout << func3(1, 2) << endl;
  return 0;
}

那么实际的作用在哪里呢？

比如包装器包装的是类的成员函数，传参的时候第一个总是类的匿名对象，写起来很麻烦。

#include<iostream>
#include <functional>
using namespace std;
class Sub
{
public:
  int sub(int a, int b)
  {
    return a - b;
  }
};
int main()
{
  function<int(int, int)> func1 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
  cout << func1(1, 2) << endl;//这里本来是三个参数，但是第一个参数已经被绑定了，包装器的参数也不用写三个了，这里也不用传三个参数了
  return 0;
}

C++11常用的一部分新特性（下）

STL容器中的empalce相关接口函数

lambda表达式

为什么要有lambda表达式

lambda表达式的格式

lambda的底层

包装器

function包装器

bind

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C++11常用的一部分新特性（下）

STL容器中的empalce相关接口函数

lambda表达式

为什么要有lambda表达式

lambda表达式的格式

lambda的底层

包装器

function包装器

bind

热门文章

最新文章

相关课程

相关电子书

相关实验场景