【C++】深入剖析C++11新特性

青衫哥

发布于 2023-10-17 08:40:51

4390

发布于 2023-10-17 08:40:51

文章被收录于专栏：C++打怪之路

一、C++11简介

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。C++11增加的语法特性非常篇幅非常多，我们这里没办法一一讲解，所以本期博客主要讲解实际中比较实用的语法。

详情参考：C++11 - cppreference.com

背景故事：

1998年是C++标准委员会成立的第一年，本来计划以后每5年视实际需要更新一次标准，C++国际标准委员会在研究C++ 03的下一个版本的时候，一开始计划是2007年发布，所以最初这个标准叫C++ 07。但是到06年的时候，官方觉得2007年肯定完不成C++ 07，而且官方觉得2008年可能也完不成。最后干脆叫C++ 0x。x的意思是不知道到底能在07还是08还是09年完成。结果2010年的时候也没完成，最后在2011年终于完成了C++标准。所以最终定名为C++11。

二、统一的列表初始化

1.｛｝初始化

在C++98中，标准允许使用花括号 {} 对数组或者结构体元素进行统一的列表初始值设定。比如：

#include <iostream>
using namespace std;

class Date
{
public:
    Date(int year, int month, int day)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {}
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    
    int arr[] = { 1,2,3,4,5 };
    Date d1 = { 2023,5,9 };

    return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自

定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

例如：

#include <iostream>
using namespace std;

class Date
{
public:
    Date(int year, int month, int day)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {}
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    int a{ 1 };
    int arr[]{ 1,2,3,4,5 };
    Date d1{2023,5,9};
    int* p = new int[4] {1, 2, 3, 4};
    Date* pd = new Date[2] { {2023, 1, 1}, { 2023,5,1 }};

    return 0;
}

2.std::initializer_list

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

在初始化vctor等容器的时候，可以直接用花括号来初始化了。

int main() {
    vector<int> v = { 1,2,3,4,5,6 };

    return 0;
}

但是这样的用法十分少，我们一般都是创建一个vector之后慢慢插入数据。

那么原理是什么呢？其实，是会先创建一个std::initializer_list来封装这个数组，再将数组其中的数据插入到容器中。

我们可以通过打印这个变量名来验证：

int main() {
    auto it= { 1,2,3,4,5,6 };
    cout << typeid(it).name() << endl;
    return 0;
}

可以看到，再C++11中新增了一种用initializer_list来构造初始化的方式

三、声明

1.auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

int main() {
    int a = 10;
    auto* p = &a;
    cout << typeid(p).name() << endl;

    map<string, string> m1 = { {"排序","sort"},{"苹果","apple"},{"手机","phone" } };
    auto it = m1.begin();

    return 0;
}

2.decltype

关键字decltype将变量的类型声明为表达式指定的类型

我们可以用来解决精度不够的问题

template<class T1,class T2>
void Add(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret;
    ret = t1 + t2;
    cout << ret << endl;
    cout << typeid(ret).name() << endl;
}
int main() {
    
    Add(3, 3.14);


    return 0;
}

例如我们上例中的 ret，我们不知道ret可能是什么类型的，如果用的 int 类型可能导致精度不够，这时候可以用decltype来判断。

3.nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

四、范围for

这是C++11增加的语法糖，确实是十分好用的。

范围for的引入，极大的方方便了我们用于遍历数组和容器内容。

遍历for底层实际上是用迭代器来完成的

int main() {
    
    int arr[] = { 1,2,3,4,5,6,7,8,9 };
    for (auto n : arr)
    {
        cout << n << " ";
    }
    cout << endl;


    vector<int> v = { 1,2,3,4,5,6,7 };
    //范围for
    for (auto n : v)
    {
        cout << n << " ";
    }
    cout << endl;
    //等价于
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }

    return 0;
}

五、final和oberride

C++ 对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug 会得不偿失，因此： C++11 提供了 override 和 final 两个关键字，可以帮助用户检测是否重写。

具体参考：【C++】三大特性之多态_

六、STL中一些变化

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和unordered_set。

1.array

库里面提供的array和我们普通的静态数组区别不大，最大的区别在于：越界检测。

我们自定义的数组越界检测属于抽检，有时候检测得出，有时候不行。但是库里的检测比较严格。

2.forward_list

这是新增的一个list容器，底层是单链表。作用其实也不是特别大。

我们可以修改接口中只有头插头删，没有尾插尾删，因为如果要对尾部操作需要找尾，

3.unordered_map和unordered_set

这两个是以哈希为底层机构封装的容器，在查找方面速度优于以红黑树为底层结构的map和set。

另外：

所有的容器都加入了移动构造函数和以std::initializer_list为参数的构造函数重载。
新增了emplace_xxx插入接口和右值引用版本的插入接口。

七、右值引用

1.右值引用和左值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是左值引用？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址（重要判断依据）+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{
	//以下都是左值
	int b = 10;
	int* p = new int;
	//左值引用
	int& rb = b;
	int*& rp = p;

	return 0;
}

什么是右值？什么是右值引用？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名.

值得一提的是，在符号上，左值引用是&，右值引用是&&。

int main()
{
	//以下是右值
	10;
	x + y;
	max(x + y);
	//右值引用
	int&& rr1 = 10;
	int&& rr2 = x + y;
	int&& rr3 = max(x + y);

	return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可

以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地

址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，

这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

2.左值引用与右值引用比较

左值引用总结：

左值引用只能引用左值，不能引用右值。
但是const左值引用既可引用左值，也可引用右值。

右值引用总结：

右值引用只能右值，不能引用左值。
但是右值引用可以move以后的左值。

int main()
{
	int a = 10;
	int&& rr1 = move(a);

	return 0;
}

3.右值引用使用场景和意义

左值引用的短板：

当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，

只能传值返回。

我们看下面代码:

string to_string(int value)
{
	string str;
	//一系列操作
	//......

	return str;
}

int main()
{
	string str2 = to_string(1234);
	return 0;
}

string to_string(int value)函数中可以看到，这里只能使用传值返回，因为str是一个临时变量，出了函数就要销毁了，是不能返回它的引用的。传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

如果是用上了右值引用的移动拷贝：

代码如下：

//移动构造
string(string&& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	swap(s, *this);
}

移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

移动构造的做法十分巧妙，反正临时变量用完就是要销毁的，不如直接把他的东西拿来用，这样就节省了一次拷贝的时间。这个方法简而言之就是：转移资源的所有权(拿来吧你！)

不仅仅有移动构造，还有移动赋值：

在bit::string类中增加移动赋值函数，再去调用bit::to_string(1234)，不过这次是将bit::to_string(1234)返回的右值对象赋值给ret1对象，这时调用的是移动构造。

//移动赋值
string& operator=(string&& s)
{
	swap(s, *this);
	return *this;
}

int main()
{
	qingshan::string str2;
	str2 = to_string(1234);
	return 0;
}

右值从广义上来说分为两种：

纯右值（内置类型表达式的值）
将亡值（自定义类型表达式的值）

总结： 左值引用是取别名，直接起作用。而右值引用是间接起作用，实现移动构造和移动赋值，在拷贝的场景，如果时将亡值，转移资源。

4.右值引用引用左值及其一些更深入的使用场景分析

我们都知道，左值是无法使用右值引用的。

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

void func(int&& x)
{
	cout << "test:move" << endl;
}

int main()
{
	
	int x = 10;
	func(move(x));
	
	return 0;
}

在右值引用问世之后，容器中也推出了移动构造和移动拷贝函数

5.万能引用

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，

但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，

#include <iostream>
using namespace std;

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

//万能引用
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10);

	int a;
	PerfectForward(a);
	PerfectForward(move(a));

	const int b = 10;
	PerfectForward(b);
	PerfectForward(move(b));

	return 0;
}

我们可以看到虽然有些传参右值，调用的仍然是左值引用，这是因为在代用万能引用之后，左值引用值仍然是左值，但是右值引用由于系统会给它提前开辟一块空间来存储，所以右值引用之后就变成了左值。

为了解决这个问题，C++11引入了完美转发。

6.完美转发

完美转发作用：完美转发在传参的过程中保留对象原生类型属性，左值在左值引用之后还是左值，右值在右值引用之后还是右值

要使用完美转发，我们需要用到forward。

注意： 万能引用和完美转发必须保证传参时，才实例化对象，如果传参前模板已经被实例化了，将构不成万能引用和完美转发。（例如我们不能用类的模版参数来作为完美转发的参数，因为在初识化类的时候就已经实例化了。）

八、新的类功能

1.默认成员函数

原来C++类中，有6个默认成员函数：

构造函数
析构函数
拷贝构造函数
拷贝赋值重载
取地址重载
const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。

C++11 新增了两个：移动构造函数和移动赋值运算符重载。

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

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

2.类成员变量初始化

C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。

3.强制生成默认函数的关键字default

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

4.禁止生成默认函数的关键字delete

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁，这样只要其他人想要调用就会报错。

在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

九、可变参数模版

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。

说到可变模版参数，其实在C语言中我们有一个非常熟悉的函数，那就是printf函数，也用到了可变参数。

接下来我们再看看可变模版参数：

可以看到参数args前面加了 ... ，这是参数包，里面包含了N个模版参数。

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

}

1.获取参数个数

之前我们用sizeof都是获取参数所占字节数，但是在可变参数这里sizeof的作用是获取参数个数。

但是我们在参数和sizeof之间要加上 ...

2.输出参数

输出参数并不能使用for循环，所以十分麻烦。

A）递归式展开参数包

void showlist()
{
	cout << endl;
}

template<class T, class ...Args>
void showlist(T val, Args ...args)
{
	cout << val << " ";
	showlist(args...);
}

int main()
{
	showlist(1, 2, 3, 4, 5);
	showlist(1, 2, "helloworld");
	return 0;
}

B）逗号表达式展开参数包（了解即可）

这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。

expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0),(printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arrsizeof...(Args)。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

3.STL emplace相关接口

empalce系列的接口也是能够使用参数包传参的。

A）emplace_back和push_back的区别

在自定义类型上，因为都是需要深拷贝的，emplace_back的优势在于可以直接用参数包来构造，免去了浅拷贝的赋值。

在内置类型上，反而优势体现更大，push_back靠参数来构造一个对象，再通过浅拷贝复制一个对象来插入。但是emplace_back则直接通过参数包来构造一个对象插入，免去了一次浅拷贝。

总结： emplace系列的价值体现在可以免去一次浅拷贝。在没有深拷贝的时候，这个优势将会很大。

十、lambda表达式

有时候，在需要传参函数指针的时候，由于函数指针不便于阅读，我们会用仿函数来代替。但是有时候多重自定义类型比较，我们需要写多个仿函数这给我们带来了极大的不便。因此C++11中新增了lambda表达式。

1.语法规则

lambda表达式书写格式：capture-list mutable -> return-type { statement}

lambda表达式各部分说明

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

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

例：

#include <algorithm>
#include <functional>

int main()
{
	auto add = [](int x, int y) {return x + y; };
	cout << add(1, 2) << endl;
	return 0;
}

这就是简单的lambda表达式的用法，因为表达式的类型我们无法打出来，只有由编译器来识别，所以我们用关键字auto来接收。

2. 捕获列表说明

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

var：表示值传递方式捕捉变量var
=：表示值传递方式捕获所有父作用域中的变量(包括this)
&var：表示引用传递捕捉变量var
&：表示引用传递捕捉所有父作用域中的变量(包括this)
this：表示值传递方式捕捉当前的this指针

int main()
{
	int a = 10;
	int b = 20;
	//只捕获a变量
	auto add1 = [a](int x, int y) {return x + y + a; };
	//捕获父作用域中全部变量
	auto add2= [=](int x, int y) {return x + y + a; };
	//引用传递方式捕获变量,能够修改捕获变量的值
	auto swap1 = [&a, &b]() {
		int temp = a;
		a = b;
		b = temp;
	};
	//引用传递方式捕获父作用域所有变量
	auto swap2 = [&]() {
		int temp = a;
		a = b;
		b = temp;
	};


	return 0;
}

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

这里捕捉列表的意思是，除了ret是引用传递捕获外，其他的都是值传递捕获。

注意： a. 父作用域指包含lambda函数的语句块，因为代码是从上往下读的，所以也只只包含上文的。 b. 捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：=, a：=已经以值传递方式捕捉了所有变量，捕捉a重复。 c. 在块作用域以外的lambda函数捕捉列表必须为空。 d. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。 e. lambda表达式之间不能相互赋值，即使看起来类型相同。

3.函数对象与lambda表达式

我们看下面代码：

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

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

	r2(10000, 2);

	return 0;
}

让我们转到反汇编：

我们不难发现，其实lambda的底层原理和仿函数是一样的。

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()，类名会用一串随机的字符串来代表。

十一、包装器

1.function包装器

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

那么我们来看看，我们为什么需要function呢？

template<class F, class T>
T useF(F f, T x)
{
	return f(x);
}

double f(double f)
{
	return f / 2;
}

struct Functor
{
	double operator()(double b)
	{
		return b / 3;
	}
};

int main()
{
	cout << useF(f, 3.0) << endl;
	cout << useF(Functor(), 3.0) << endl;
	cout << useF([](double d) {return d / 4; }, 3.0) << endl;
	

	return 0;
}

我们分别用函数、仿函数、lambda表达式来调用了useF，那么模版就要实例化出三份。

包装器可以很好解决实例多份的情况。

A）包装器function原型：

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

B）使用方法：

functionr<返回值（参数) >

代码:

#include <functional>
template<class F, class T>
T usef(F f, T x)
{
	return f(x);
}

double f(double a,double b)
{
	return a / b;
}

struct Functor
{
	double operator()(double a, double b)
	{
		return a / b;
	}
};

class temp
{
public:
	double divsion(double a, double b)
	{
		return a / b;
	}

private:
	int a;
	int b;
};

int main()
{
	//函数
	function<double(double,double)> func1 = f;
	cout << func1(1, 2) << endl;

	//仿函数
	function<double(double, double)> func2 = Functor();
	cout << func2(1, 2) << endl;

	//lambda表达式
	function<double(double, double)> func3 = [](double a, double b) {return a / b; };
	cout << func3(1, 2) << endl;
	
	//类的成员函数
	function<double(temp, double, double)> func4 = &temp::divsion;
	cout << func4(temp(), 1, 2) << endl;


	return 0;
}

这里有几个注意点: 1. function尖括号中第一个参数是返回值，然后第二个参数是函数的参数。 2. 包装器包装类的成员函数的时候，非静态函数第一个参数需要传类名，在赋值的时候需要带上类域，函数需要取地址，静态函数只需要在赋值的时候需要带上类域（这里建议都取地址，方便记忆）。原因：静态成员函数没有 this 指针，所以 function 类实例化时不需要添加一个成员函数所属类的类型参数，在调用时也不需要传递一个成员函数所属类的对象；而非静态成员则有，所以需要借助类对象来传递。 3. 在使用包装了类的成员函数的包装器的时候，我们第一个参数也要传一个类对象。

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为第二个参数，以此类推。

使用代码:

int main()
{
	auto func1 = bind(f, placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;

	auto func2 = bind(Functor(), placeholders::_1, placeholders::_2);
	cout << func2(1, 2) << endl;

	return 0;
}

这里的placeholders是占位参数。

A）调整参数顺序

int main()
{
	auto func1 = bind(f, placeholders::_2, placeholders::_1);
	cout << func1(1, 2) << endl;

	return 0;
}

我们通过调换占位参数placeholders之间的顺序来实现调换参数顺序。使得结果相反。

B）调整参数个数

我们在使用包装器的时候调用类内的函数需要传类对象，我们可以通过bind绑定类对象，这样后面再调用的时候就不需要传类对象了。

bind在实际中使用并不多，了解即可。

关于智能指针和线程库，后面我会单独发一篇博客来详细叙述。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2023-05-16，如有侵权请联系 cloudcommunity@tencent.com 删除

c++

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！