【C++从0到王者】第三十九站：C++11（全文三万字，超详解）（下）-阿里云开发者社区

2.lambda表达式语法

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

各部分说明

lambda表达式各部分说明

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量提供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量

如下代码所示

int main()
{
  int a = 0;
  int b = 2;
  auto add1 = [](int x, int y) ->int {return x + y; };
  auto add2 = [](int x, int y) {return x + y; };
  cout << add1(a, b) << endl;
  cout << add2(a, b) << endl;
  return 0;
}

除此以外还可以写多行语句等等

但是要注意的是，我们如果直接去调用其他的局部的lambda表达式的话,会报错的

但是如果是一个全局的，是可以的

那么有没有办法可以使用局部的呢？其实是有的，那就是捕捉列表，比如下面的代码

那么捕捉列表有哪些捕捉方式呢？

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

[var]：表示值传递方式捕捉变量var,捕捉后为const类型

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)，捕捉后为const类型

[&var]：表示引用传递捕捉变量var

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)

[this]：表示值传递方式捕捉当前的this指针

注意事项:

a. 父作用域指包含lambda函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。

比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空。

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。

f. lambda表达式之间不能相互赋值，即使看起来类型相同

首先需要特别注意的是捕捉列表出来的是不可以修改的，如下代码所示

如果真的想修改捕捉到的变量，可以加上mutable

不过这里的mutable仅仅只是让这个变量可以被修改了。但是这里是传值的，里面的修改并不会影响外面的。实际上这个用处不大

如果想修改外面的，可以使用引用捕捉

我们还可以试一下下面的代码

int main()
{
  int a = 0;
  int b = 1;
  int c = 2;
  int d = 3;
  int e = 4;
  cout << a << " " << b << " " << c << " " << d << " " << e << endl;
  auto func = [&] {
    a++;
    b++;
    c++;
    d++;
    e++;
  };
  func();
  cout << a << " " << b << " " << c << " " << d << " " << e << endl;
  return 0;
}

除此之外，还可以混合着来，下面代码是错的，因为a不可以被修改，意思是除了a以外所有的变量使用引用捕捉，而a用值传递的方式捕捉。而a值捕捉以后是不可被修改的，所以错误

而且引用捕捉是可以捕捉const变量的。只不过捕捉以后无法修改，但是可以进行访问，他们的地址都是一样的

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

3.函数对象与lambda表达式

当我们写出这样的代码的时候，我们会发现报错了

于是我们打印出他们类型来观察一下

我们会发现其实这两个对象的类型其实是不一样的。所以当然无法赋值。

其实lambda表达式的底层就是仿函数，这里的f1,f2都是一些仿函数对象，只不过他们的类型是编译器自己生成的。我们看不到而已。

我们这里通过f1去调用的其实都是仿函数的调用

我们可以用如下代码来进行观察

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

下面是对于仿函数的，可以看到调用了构造函数和operator()

下面是对于lambda表达式的，我们也可以看到调用了构造函数和operator()

所以lambda表达式底层其实就是仿函数，就像范围for的底层是迭代器一样

八、可变参数模板

1.可变参数模板

我们知道，printf这个函数就是一个可变参数的

这里的三个点就代表了，可以写任意个参数

这里面其实就相当于有一个数组把这个实参存起来，然后printf会依次访问数组里面的元素。

以上就是函数的可变参数

而模板参数和函数参数是很类似的，模板参数传递的是类型，函数参数传递的是对象。函数的可变参数是传多个对象，而模板的可变参数就是可以传多个类型

Args是一个模板参数包，args是一个函数形参参数包

声明一个参数包Args…args，这个参数包中可以包含0到任意个模板参数。

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

如下代码所示可以计算出有多少个可变参数

template<class T, class ...Args>
void Showlist(T value, Args... args)
{
  cout << sizeof...(args) << endl;
}
int main()
{
  Showlist(1);
  Showlist(1, 1.1);
  Showlist(1, 1.1, 1.2);
  Showlist(1, 1.1, 1.3, 1.2);
  return 0;
}

我们还需要注意的是，如果我们想要访问参数包的话

不可以想当然的以为这样可以取出参数包的内容，这样是错的代码，编译不通过。

我们需要这样访问

template<class T>
void Showlist(T value)
{
  cout << value << endl;
}
template<class T, class ...Args>
void Showlist(T value, Args... args)
{
  cout << value << " ";
  Showlist(args...);
}
int main()
{
  Showlist(1);
  Showlist(1, 1.1);
  Showlist(1, 1.1, 1.2);
  Showlist(1, 1.1, 1.3, 1.2);
  return 0;
}

它这里其实就用了一个编译时的递归。

一开始会将第一个参数传给T，然后剩下的参数包都传给下一层函数。最上面就是结束条件。

在库里面就有一个类似的接口

不过它的参数只有一个参数包，那么应该如何传递呢？其实我们可以使用一个子函数

void _Showlist()
{
  cout << endl;
}
template<class T, class ...Args>
void _Showlist(T value, Args... args)
{
  cout << value << " ";
  _Showlist(args...);
}
template<class ...Args>
void Showlist(Args... args)
{
  _Showlist(args...);
}
int main()
{
  Showlist(1);
  Showlist(1, 1.1);
  Showlist(1, 1.1, 1.2);
  Showlist(1, 1.1, 1.3, 1.2);
  return 0;
}

其实像上面的几个函数组合起来，就相当于一个C++版本的print了，可以自动打印

关于这个打印，其实还可以这样玩

这里的核心逻辑就是，在Showlist中，会将参数包传给PrintArg这个函数，这个函数只会解析第一个参数，后面的逗号是一个逗号表达式，用于初始化数组，后面的三个点就是有几个参数就会相当于调用了几次PrintArg这个函数

void Showlist()
{
  cout << endl;
}
template<class T>
void PrintArg(T t)
{
  cout << t << " ";
}
template<class ...Args>
void Showlist(Args... args)
{
  int a[] = { (PrintArg(args),0)... };
  cout << endl;
}
int main()
{
  Showlist(1);
  Showlist(1, 1.1);
  Showlist(1, 1.1, 1.2);
  Showlist(1, 1.1, 1.3, 1.2, string("xxxxx"));
  return 0;
}

运行结果是

不过这段代码其实还可以稍微简化一下

不过上面的方法是一次一次取出来的，能不能一次性全部取出来呢？方便我们进行初始化等操作

如下代码所示，这样的话，我们就可以通过Create函数去调用各种情况的构造函数了，还有拷贝构造函数也可以去调用。特别灵活

class Date
{
public:
  Date(int year = 0, int month = 0, int day = 0)
    :_year(year)
    , _month(month)
    , _day(day)
  {}
private:
  int _year;
  int _month;
  int _day;
};
template<class ...Args>
Date* Create(Args... args)
{
  Date* ret = new Date(args...);
  return ret;
}
int main()
{
  Date* p1 = Create();
  Date* p2 = Create(2023);
  Date* p3 = Create(2023, 10);
  Date* p4 = Create(2023, 10, 22);
  Date d(2023, 10, 1);
  Date* p5 = Create(d);
  return 0;
}

2.emplace系列

如下接口所示，在C++11以后，很多库里面都加上了emplace系列接口

我们先看以下代码

int main()
{
  std::list< std::pair<int, char> > mylist;
  mylist.push_back(make_pair(40, 'd'));
  mylist.push_back({ 50, 'e' });
  for (auto e : mylist)
    cout << e.first << ":" << e.second << endl;
  return 0;
}

这些代码都是我们之前的正常的尾插

现在有了emplace以后，我们就可以下面的写法了。

这是因为与前面的Date的实现是一样的，通过可变参数模板实现的。

int main()
{
  std::list< std::pair<int, char> > mylist;
  // emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
  // 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
  mylist.emplace_back(10, 'a');
  mylist.emplace_back(20, 'b');
  mylist.emplace_back(make_pair(30, 'c'));
  mylist.push_back(make_pair(40, 'd'));
  mylist.push_back({ 50, 'e' });
  for (auto e : mylist)
    cout << e.first << ":" << e.second << endl;
  return 0;
}

也许我们也会听说emplace_back的效率更高一些，但是在上面的场景是看不出来的，下面的场景可以感受出来

int main()
{
  // 下面我们试一下带有拷贝构造和移动构造的Sim::string，再试试呢
  // 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
  // 是先构造，再移动构造，其实也还好。
  std::list< std::pair<int, Sim::string> > mylist;
  mylist.emplace_back(10, "sort");
  mylist.emplace_back(make_pair(20, "sort"));
  mylist.push_back(make_pair(30, "sort"));
  mylist.push_back({ 40, "sort" });
  return 0;
}

虽然emplace效率稍高一些，但是其实还好，因为并没有太大差距，因为移动拷贝的效率很低

要是真要说的，反倒是内置类型和浅拷贝的效率可以提高一些，因为深拷贝的量级基本在一个量级。而浅拷贝是就显得差距比较大了

class Date
{
public:
  Date(int year = 0, int month = 0, int day = 0)
    :_year(year)
    , _month(month)
    , _day(day)
  {
    cout << "Date(int year = 0, int month = 0, int day = 0)" << endl;
  }
  Date(const Date& d)
    :_year(d._year)
    , _month(d._month)
    , _day(d._day)
  {
    cout << "Date(const Date& d)" << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  std::list< Date > mylist;
  mylist.push_back(Date(2023, 10, 23));
  cout << endl;
  mylist.emplace_back(2023, 10, 23);
  return 0;
}

其中最为核心的原因就是emplace可以传参数包，这就导致了它可以传对象，可以传对象过去。而push_back只能传对象

九、新的类功能

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:
  Sim::string _name;
  int _age;
};
int main()
{
  Person s1;
  Person s2 = s1;
  Person s3 = std::move(s1);
  Person s4;
  s4 = std::move(s2);
  return 0;
}

这是利用了编译器自己生成的移动拷贝

当这些类都写了的时候，调用深拷贝

如果屏蔽三个中的一个，依然是深拷贝

事实上，一般而言，我们只需判断拷贝构造、赋值重载、析构中的任意一个就可以了。因为他们三个如果要实现一般都是一起实现的，共存亡的。因为一旦写析构了必然涉及到资源的释放，涉及到了资源就必然涉及到了深拷贝。所以我们一般只要其中的一个没写那么三个基本上都不会写的。

2.一些新的关键字

**类成员变量初始化：**C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。
强制生成默认函数的关键字default:
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成

比如如下的例子

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

继承和多态中的final与override关键字：final用于防止类被继承，不能被重写。override用于必须重写该虚函数

十、包装类

1.function包装器

lambda表达式很好用，但是它也有一些缺陷，那就是他的类型我们不知道，所以导致传参的时候非常难弄

面对C++中各种各样的类型，比如函数指针，仿函数，lambda表达式，有没有什么办法可以将他们统一起来呢？

我们先看下面的代码

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

从运行结果上来看，这个模板被实例化成了三份

可见他们的类型各不相同，我们能否找一种办法使得只实例化成一份呢？

也就是说，将可调用对象存储到一个容器中

std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret : 被调用函数的返回类型
Args…：被调用函数的形参

所以我们可以改善前面的代码

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;
  function<double(double)> f1 = f;
  function<double(double)> f2 = Functor();
  function<double(double)> f3 = [](double d)->double { return d / 4; };
  vector<function<double(double)>> v = { f1,f2,f3 };
  double n = 3.3;
  for (auto f : v)
  {
    cout << f(n++) << endl;
  }
  return 0;
}

所以这里就完美的解决了可调用对象的类型问题

我们可以将包装器用于下面题目的改造

逆波兰表达式求值

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string,function<int(int,int)>> cmdFuncMap = {
            {"+",[](int left, int right){return left + right;}},
            {"-",[](int left, int right){return left - right;}},
            {"*",[](int left, int right){return left * right;}},
            {"/",[](int left, int right){return left / right;}}
        };
        for(auto& str : tokens)
        {
            if(cmdFuncMap.count(str))
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                st.push(cmdFuncMap[str](left,right));
            }
            else
            {
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

而且这样改造之后，如果要添加运算，只需要去往map里面加数据即可，不需要做出其他改动

还是对于前面的代码，有了包装器，我们就可以将类只实例化出一份，因为可以统一成一个类型了。

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()
{
  function<double(double)> f1 = f;
  function<double(double)> f2 = Functor();
  function<double(double)> f3 = [](double d)->double { return d / 4; };
  cout << useF(f1, 11.11) << endl;
  // 函数对象
  cout << useF(f2, 11.11) << endl;
  // lamber表达式
  cout << useF(f3, 11.11) << endl;
  return 0;
}

2.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);

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

调用bind的一般形式：auto newCallable = bind(callable,arg_list);

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推

下面就是一个使用bind的例子

int Sub(int x, int y)
{
  return x - y;
}
int main()
{
  function<int(int, int)> rSub1 = bind(Sub, placeholders::_1, placeholders::_2);
  cout << rSub1(10, 5) << endl;
  function<int(int, int)> rSub2 = bind(Sub, placeholders::_2, placeholders::_1);
  cout << rSub2(10, 5) << endl;
  return 0;
}

运行结果为

我们来详解分解一下这段代码

其实placeholders是一个命名空间，里面有很多的变量，我们先不用仔细考虑。会用就可以了

在rSub这一层第几个参数传递给下标是几的参数，但是在由进一步传入Sub的时候，是按照顺序传递的，所以导致了传递顺序的不同，从而导致了结果的不同。

所以说，这个bind的价值就是交换传递的参数顺序。

因为有一些函数的接口我们需要调整一下顺序，这时候bind就起到了很大的作用了。

而且当我们对于3个参数的函数，如果我们只想要传递两个参数，那么我们也可以用bind

double Sub(int x, int y, double rate)
{
  return (x - y) * rate;
}
int main()
{
  function<double(int, int)> rSub1 = bind(Sub, placeholders::_1, placeholders::_2, 4.2);
  function<double(int, int)> rSub2 = bind(Sub, placeholders::_1, placeholders::_2, 4.3);
  function<double(int, int)> rSub3 = bind(Sub, placeholders::_1, placeholders::_2, 4.4);
  cout << rSub1(10, 5) << endl;
  cout << rSub2(10, 5) << endl;
  cout << rSub3(10, 5) << endl;
  return 0;
}

如果我们想要将固定的参数给到前面，那就是这样的，注意一定是从_1开始的下标

double Sub(int x, int y, double rate)
{
  return (x - y) * rate;
}
double RSub(double rate, int x, int y)
{
  return (x - y) * rate;
}
int main()
{
  function<double(int, int)> rSub1 = bind(Sub, placeholders::_1, placeholders::_2, 4.2);
  function<double(int, int)> rSub2 = bind(Sub, placeholders::_1, placeholders::_2, 4.3);
  function<double(int, int)> rSub3 = bind(Sub, placeholders::_1, placeholders::_2, 4.4);
  cout << rSub1(10, 5) << endl;
  cout << rSub2(10, 5) << endl;
  cout << rSub3(10, 5) << endl;
  function<double(int, int)> rSub4 = bind(RSub, 4.5, placeholders::_1, placeholders::_2);
  function<double(int, int)> rSub5 = bind(RSub, 4.2, placeholders::_1, placeholders::_2);
  cout << rSub4(10, 5) << endl;
  cout << rSub5(10, 5) << endl;
  return 0;
}

因为这个_1和_2其实是给rsub看的。只有他们才会去看这些下标，后面的都是直接传递的

如下所示的场景中，

我们需要注意的是，如果某个函数是某个类域里面的，我们还要记得写上访问限定符，因为它只能访问到这个局部域和全局域中的。

对于静态的函数，写上类域就可以了，但是对于非静态的，它的地址还需要加上取地址符号，静态的可以加也可以不加，除此之外，还需要传递一个this指针，为此我们需要定义一个对象，才能传过去，或者直接传递一个对象也是可以的

class SubType
{
public:
  static int Sub(int x, int y)
  {
    return (x - y);
  }
  int SSub(int x, int y, double rate)
  {
    return (x - y) * rate;
  }
};
int main()
{
  function<int(int, int)> rSub5 = bind(SubType::Sub, placeholders::_1, placeholders::_2);
  SubType sb;
  function<int(int, int)> rSub6 = bind(&SubType::SSub, &sb, placeholders::_1, placeholders::_2, 3);
  function<int(int, int)> rSub7 = bind(&SubType::SSub, SubType(), placeholders::_1, placeholders::_2, 3);
  cout << rSub5(10, 5) << endl;
  cout << rSub6(10, 5) << endl;
  cout << rSub7(10, 5) << endl;
  return 0;
}

对于类域中的非静态，传地址我们可以理解，但是为什么可以传对象呢？

其实bind的底层其实也是仿函数，在这个变量这里重载了operator()，可以根据传入的是对象还是指针去决定最终传递哪一个。所以可以可以传一个对象过去

不过要切记，不可以给匿名对象取地址，因为右值无法取地址

【C++从0到王者】第三十九站：C++11（全文三万字，超详解）（下）

2.lambda表达式语法

3.函数对象与lambda表达式

八、可变参数模板

1.可变参数模板

2.emplace系列

九、新的类功能

1.新增的默认成员函数

2.一些新的关键字

十、包装类

1.function包装器

2.bind

热门文章

最新文章

相关课程

相关电子书

相关实验场景