C++:C++11介绍

Chris-zz 2024-08-16 14:05:04 阅读 67

✨✨✨学习的道路很枯燥,希望我们能并肩走下来!

文章目录

目录

文章目录

前言

一、C++11简介

二 统一的列表初始化

2.1 {} 初始化

2.2 std::initializer_list

三 声明

3.1 auto 

3.2 decltype 

 3.3 nullptr

四 范围for循环 

五 智能指针 

六 STL中一些变化 

七 右值引用和移动语义 

7.1 左值引用和右值引用 

7.2 左值引用与右值引用比较 

 7.3 右值引用使用场景和意义

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

7.5 完美转发 

八 新的类功能 

8.1 默认成员函数 

8.2 类成员变量初始化

8.3 强制生成默认函数的关键字default:

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

 8.5 继承和多态中的final与override关键字

 九 可变参数模板

 十 lambda表达式

10.1 C++98中的一个例子 

10.2 lambda表达式 

10.3 lambda表达式语法 

10.4 函数对象与lambda表达式 

十一  包装器 

11.1function包装器 

11.2 bind 

​编辑十二 线程库

总结



前言

本篇详细介绍了进一步介绍C++11,让使用者对C++11有更加深刻的认知,而不是仅仅停留在表面,更好的模拟,为了更好的使用. 文章可能出现错误,如有请在评论区指正,让我们一起交流,共同进步!


一、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增加的语法特性非常篇幅非常多,我们这里没办法一 一讲解,所以本文主要讲解实际中比较实用的语法。

https://en.cppreference.com/w/cpp/11

小故事:

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。 

二 统一的列表初始化

2.1 {} 初始化

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

<code>struct Point

{

int _x;

int _y;

};

int main()

{

int array1[] = { 1, 2, 3, 4, 5 };

int array2[5] = { 0 };

Point p = { 1, 2 };

return 0;

}

 C++11扩大了用大括号括起的列表(初始化列表)的使用范围,使其可用于所有的内置类型和用户自 定义的类型使用初始化列表时,可添加等号(=),也可不添加。

struct Point

{

int _x;

int _y;

};

int main()

{

int x1 = 1;

int x2{ 2 };

int array1[]{ 1, 2, 3, 4, 5 };

int array2[5]{ 0 };

Point p{ 1, 2 };

// C++11中列表初始化也可以适用于new表达式中

int* pa = new int[4]{ 0 };

return 0;

}

 创建对象时也可以使用列表初始化方式调用构造函数初始化

class Date

{

public:

Date(int year, int month, int day)

:_year(year)

,_month(month)

,_day(day)

{

cout << "Date(int year, int month, int day)" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1(2022, 1, 1); // old style

// C++11支持的列表初始化,这里会调用构造函数初始化

Date d2{ 2022, 1, 2 };

Date d3 = { 2022, 1, 3 };

return 0;

}

2.2 std::initializer_list

std::initializer_list的介绍文档: 

http://www.cplusplus.com/reference/initializer_list/initializer_list/

std::initializer_list是什么类型: 

int main()

{

// the type of il is an initializer_list

auto il = { 10, 20, 30 };

cout << typeid(il).name() << endl;

return 0;

}

 std::initializer_list使用场景:

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

<code>int main()

{

vector<int> v = { 1,2,3,4 };

list<int> lt = { 1,2 };

// 这里{"sort", "排序"}会先初始化构造一个pair对象

map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };

// 使用大括号对容器赋值

v = {10, 20, 30};

return 0;

}

 std::initializer_list的本质:

可变参数列表 栈上开辟一个数组,并将其开头和结尾的指针存到可变参数列表

Sizeof可以证明这一点

X86环境下每个指针大小为4

让模拟实现的vector也支持{}初始化和赋值 

<code>namespace ch

{

template<class T>

class vector {

public:

typedef T* iterator;

vector(initializer_list<T> l)

{

_start = new T[l.size()];

_finish = _start + l.size();

_endofstorage = _start + l.size();

iterator vit = _start;

typename initializer_list<T>::iterator lit = l.begin();

while (lit != l.end())

{

*vit++ = *lit++;

}

//for (auto e : l)

// *vit++ = e;

}

vector<T>& operator=(initializer_list<T> l) {

vector<T> tmp(l);

std::swap(_start, tmp._start);

std::swap(_finish, tmp._finish);

std::swap(_endofstorage, tmp._endofstorage);

return *this;

}

private:

iterator _start;

iterator _finish;

iterator _endofstorage;

};

}

三 声明

c++11提供了多种简化声明的方式,尤其是在使用模板时。 

3.1 auto 

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

        这个我们在C++入门讲过,这里就不再赘述 

3.2 decltype 

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

// decltype的一些使用使用场景

template<class T1, class T2>

void F(T1 t1, T2 t2)

{

decltype(t1 * t2) ret;

cout << typeid(ret).name() << endl;

}

int main()

{

const int x = 1;

double y = 2.2;

decltype(x * y) ret; // ret的类型是double

decltype(&x) p; // p的类型是int*

cout << typeid(ret).name() << endl;

cout << typeid(p).name() << endl;

F(1, 'a');

return 0;

}

 3.3 nullptr

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

(C++不能将void*指针隐式类型转化为其他类型的指针,C可以) 

#ifndef NULL

#ifdef __cplusplus

#define NULL   0

#else

#define NULL   ((void *)0)

#endif

#endif 

四 范围for循环 

这个我们在前面的课程中已经进行了非常详细的讲解,这里就不进行讲解了,请参考C++入门 +STL容器部分的博客。 

五 智能指针 

这个我在下篇智能指针博客中已经会进行了非常详细的讲解,这里就不进行讲解了 

六 STL中一些变化 

新容器 

用橘色圈起来是C++11中的一些几个新容器,但是实际最有用的是unordered_map和 unordered_set。这两个我们前面已经进行了非常详细的讲解,其他的大家了解一下即可 

容器中的一些新方法 

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法,但是其实很多都是用得 比较少的。

比如提供了cbegin和cend方法返回const迭代器等等,但是实际意义不大,因为begin和end也是 可以返回const迭代器的,这些都是属于锦上添花的操作。 

实际上C++11更新后,容器中增加的新方法最后用的插入接口函数的右值引用版本: 

但是这些接口到底意义在哪?网上都说他们能提高效率,他们是如何提高效率的?

请看下面的右值引用和移动语义章节的讲解。 

七 右值引用和移动语义 

7.1 左值引用和右值引用 

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

什么是左值?什么是左值引用? 

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

<code>int main()

{

// 以下的p、b、c、*p都是左值

int* p = new int(0);

int b = 1;

const int c = 2;

// 以下几个是对上面左值的左值引用

int*& rp = p;

int& rb = b;

const int& rc = c;

int& pvalue = *p;

return 0;

}

什么是右值?什么是右值引用? 

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

int main()

{

double x = 1.1, y = 2.2;

// 以下几个都是常见的右值

10;

x + y;

fmin(x, y);

// 以下几个都是对右值的右值引用

int&& rr1 = 10;

double&& rr2 = x + y;

double&& rr3 = fmin(x, y);

// 这里编译会报错:error C2106: “=”: 左操作数必须为左值

10 = 1;

x + y = 1;

fmin(x, y) = 1;

return 0;

}

 需要注意的是右值是不能取地址的,但是给右值取别名后,会导致右值被存储到特定位置,且可 以取到该位置的地址,也就是说例如:不能取字面量10的地址,但是rr1引用后,可以对rr1取地 址,也可以修改rr1。如果不想rr1被修改,可以用const int&& rr1 去引用,是不是感觉很神奇, 这个了解一下实际中右值引用的使用场景并不在于此,这个特性也不重要。

7.2 左值引用与右值引用比较 

左值引用总结: 

1. 左值引用只能引用左值,不能引用右值。

2. 但是const左值引用既可引用左值,也可引用右值。 

int main()

{

// 左值引用只能引用左值,不能引用右值。

int a = 10;

int& ra1 = a; // ra为a的别名

//int& ra2 = 10; // 编译失败,因为10是右值

// const左值引用既可引用左值,也可引用右值。

const int& ra3 = 10;

const int& ra4 = a;

return 0;

}

 右值引用总结:

        1. 右值引用只能右值,不能引用左值。

        2. 但是右值引用可以move以后的左值。

<code>int main()

{

// 右值引用只能右值,不能引用左值。

int&& r1 = 10;

// error C2440: “初始化”: 无法从“int”转换为“int &&”

// message : 无法将左值绑定到右值引用

int a = 10;

int&& r2 = a;

// 右值引用可以引用move以后的左值

int&& r3 = std::move(a);

return 0;

}

总结:汇编阶段没有左值右值之分,只会在语法检查时有所区分  (左右值可互相转 说明(只是在语法层上有区别,数据层都是一样的)

                Move本质上是强制类型转换 

 7.3 右值引用使用场景和意义

前面我们可以看到左值引用既可以引用左值和又可以引用右值,那为什么C++11还要提出右值引 用呢?是不是化蛇添足呢?下面我们来看看左值引用的短板,右值引用是如何补齐这个短板的! 

左值引用的使用场景: 

做参数和做返回值都可以提高效率。 

void func1(bit::string s)

{}

void func2(const bit::string& s)

{}

int main()

{

bit::string s1("hello world");

// func1和func2的调用我们可以看到左值引用做参数减少了拷贝,提高效率的使用场景和价值

func1(s1);

func2(s1);

// string operator+=(char ch) 传值返回存在深拷贝

// string& operator+=(char ch) 传左值引用没有拷贝提高了效率

s1 += '!';

return 0;

}

 左值引用的短板:

但是当函数返回对象是一个局部变量,出了函数作用域就不存在了,就不能使用左值引用返回, 只能传值返回。例如:bit::string to_string(int value)函数中可以看到,这里只能使用传值返回, 传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。 

右值引用和移动语义解决上述问题:  

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

<code>string(string&& s)

:_str(nullptr)

, _size(0)

, _capacity(0)

{

cout << "string(string&& s) -- 移动语义" << endl;

swap(s);

}

int main()

{

bit::string ret2 = bit::to_string(-1234);

return 0;

}

 再运行上面bit::to_string的两个调用,我们会发现,这里没有调用深拷贝的拷贝构造,而是调用 了移动构造,移动构造中没有新开空间,拷贝数据,所以效率提高了。

 不仅仅有移动构造,还有移动赋值

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

<code>// 移动赋值

string& operator=(string&& s)

{

cout << "string& operator=(string&& s) -- 移动语义" << endl;

swap(s);

return *this;

}

int main()

{

bit::string ret1;

ret1 = bit::to_string(1234);

return 0;

}

// 运行结果:

// string(string&& s) -- 移动语义

// string& operator=(string&& s) -- 移动语义

 这里运行后,我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象 接收,编译器就没办法优化了。bit::to_string函数中会先用str生成构造生成一个临时对象,但是 我们可以看到,编译器很聪明的在这里把str识别成了右值调用了移动构造然后在把这个临时对象做为bit::to_string函数调用的返回值赋值给ret1,这里调用的移动赋值。

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

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

迷惑性问题 :

int main()

{

bit::string s1("hello world");

// 这里s1是左值,调用的是拷贝构造

bit::string s2(s1);

// 这里我们把s1 move处理以后, 会被当成右值,调用移动构造

// 但是这里要注意,一般是不要这样用的,因为我们会发现s1的

// 资源被转移给了s3,s1被置空了。

bit::string s3(std::move(s1));

return 0;

}

STL容器插入接口函数也增加了右值引用版本 

7.5 完美转发 

模板中的&& 万能引用 (也可叫引用折叠)

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(std::move(a)); // 右值

const int b = 8;

PerfectForward(b); // const 左值

PerfectForward(std::move(b)); // const 右值

return 0;

}

这里的t退化成左值 

std::forward 完美转发在传参的过程中保留对象原生类型属性 

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

// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。

template<typename T>

void PerfectForward(T&& t)

{

Fun(std::forward<T>(t));

}

int main()

{

PerfectForward(10); // 右值

int a;

PerfectForward(a); // 左值

PerfectForward(std::move(a)); // 右值

const int b = 8;

PerfectForward(b); // const 左值

PerfectForward(std::move(b)); // const 右值

return 0;

}

八 新的类功能 

8.1 默认成员函数 

原来C++类中,有6个默认成员函数:

1. 构造函数

2. 析构函数

3. 拷贝构造函数

4. 拷贝赋值重载

5. 取地址重载

6. const 取地址重载 

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

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

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

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

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

3. 如果你提供了移动构造或者移动赋值,编译器不会自动提供拷贝构造和拷贝赋值。 

8.2 类成员变量初始化

C++11允许在类定义时给成员变量初始缺省值,默认生成构造函数会使用这些缺省值初始化,这 个我们在类和对象默认就讲了,这里就不再细讲了。 

8.3 强制生成默认函数的关键字default:

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

<code>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:

string _name;

int _age;

};

int main()

{

Person s1;

Person s2 = s1;

Person s3 = std::move(s1);

return 0;

}

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

如果能想要限制某些默认函数的生成,在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) = delete;

private:

string _name;

int _age;

};

int main()

{

Person s1;

Person s2 = s1;

Person s3 = std::move(s1);

return 0;

}

 8.5 继承和多态中的final与override关键字

这个我们在继承和多态章节已经进行了详细讲解这里就不再细讲,需要的话去复习继承和多台章 节吧。

 九 可变参数模板

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板,相比 C++98/03,类模版和函数模版中只能含固定数量的模版参数,可变模版参数无疑是一个巨大的改 进。然而由于可变模版参数比较抽象,使用起来需要一定的技巧,所以这块还是比较晦涩的。现 阶段呢,我们掌握一些基础的可变参数模板特性就够我们用了,所以这里我们点到为止,以后大 家如果有需要,再可以深入学习。 

下面就是一个基本可变参数的函数模板 

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

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

template <class ...Args>

void ShowList(Args... args)

{}

上面的参数args前面有省略号,所以它就是一个可变模版参数,我们把带省略号的参数称为“参数 包”,它里面包含了0到N(N>=0)个模版参数。我们无法直接获取参数包args中的每个参数的, 只能通过展开参数包的方式来获取参数包中的每个参数,这是使用可变模版参数的一个主要特 点,也是最大的难点,即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变 参数,所以我们的用一些奇招来一一获取参数包的值。 

 

递归函数方式展开参数包 

<code>// 递归终止函数

template <class T>

void ShowList(const T& t)

{

cout << t << endl;

}

// 展开函数

template <class T, class ...Args>

void ShowList(T value, Args... args)

{

cout << value << " ";

ShowList(args...);

}

int main()

{

ShowList(1);

ShowList(1, 'A');

ShowList(1, 'A', std::string("sort"));

return 0;

}

编译时递归推导 

 逗号表达式展开参数包

这种展开参数包的方式,不需要通过递归终止函数,是直接在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 arr[sizeof... (Args)]。 由于是逗号表达式,在创建数组的过程中会先执行逗号表达式前面的部分printarg(args) 打印出参数,也就是说在构造int数组的过程中就将参数包展开了,这个数组的目的纯粹是为了在数组构造的过程展开参数包(用于推导

<code>template <class T>

void PrintArg(T t)

{

cout << t << " ";

}

//展开函数

template <class ...Args>

void ShowList(Args... args)

{

int arr[] = { (PrintArg(args), 0)... };

cout << endl;

}

int main()

{

ShowList(1);

ShowList(1, 'A');

ShowList(1, 'A', std::string("sort"));

return 0;

}

 本质是根据模板参数包构造,可变参数模板帮你减少很多模板

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

<code>template <class... Args>

void emplace_back (Args&&... args);

 首先我们看到的emplace系列的接口,支持模板的可变参数,并且万能引用。那么相对insert和 emplace系列接口的优势到底在哪里呢?

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;

}

int main()

{

// 下面我们试一下带有拷贝构造和移动构造的bit::string,再试试呢

// 我们会发现其实差别也不到,emplace_back是直接构造了,push_back

// 是先构造,再移动构造,其实也还好。

std::list< std::pair<int, bit::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;

}

具体例子: 

只有一次构造 的做法:

之后不解析参数包,只是将参数包向下传递匹配 

然后直接构造 

 十 lambda表达式

10.1 C++98中的一个例子 

在C++98中,如果想要对一个数据集合中的元素进行排序,可以使用std::sort方法。 

<code>#include <algorithm>

#include <functional>

int main()

{

int array[] = { 4,1,8,5,3,7,0,9,2,6 };

// 默认按照小于比较,排出来结果是升序

std::sort(array, array + sizeof(array) / sizeof(array[0]));

// 如果需要降序,需要改变元素的比较规则

std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());

return 0;

}

 如果待排序元素为自定义类型,需要用户定义排序时的比较规则:

#include<iostream>

#include <vector>

#include<algorithm>

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

 随着C++语法的发展,人们开始觉得上面的写法太复杂了,每次为了实现一个algorithm算法, 都要重新去写一个类,如果每次比较的逻辑不一样,还要去实现多个类,特别是相同类的命名, 这些都给编程者带来了极大的不便。因此,在C++11语法中出现了Lambda表达式。

10.2 lambda表达式 

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._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; });

}

 上述代码就是使用C++11中的lambda表达式来解决,可以看出lambda表达式实际是一个匿名函 数。

10.3 lambda表达式语法 

注意:

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

<code>int main()

{

// 最简单的lambda表达式, 该lambda表达式没有任何意义

[] {};

// 省略参数列表和返回值类型,返回值类型由编译器推导为int

int a = 3, b = 4;

[=] {return a + 3; };

// 省略了返回值类型,无返回值类型

auto fun1 = [&](int c) {b = a + c; };

fun1(10);

cout << a << " " << b << endl;

// 各部分都很完善的lambda函数

auto fun2 = [=, &b](int c)->int {return b += a + c; };

cout << fun2(10) << endl;

// 复制捕捉x

int x = 10;

auto add_x = [x](int a) mutable { x *= 2; return a + x; };

cout << add_x(10) << endl;

return 0;

}

 通过上述例子可以看出,lambda表达式实际上可以理解为无名函数,该函数无法直接调用,如果想要直接调用,可借助auto将其赋值给一个变量。

2. 捕获列表说明 

PS:PS: 任何一对花括号({})中的语句集都属于一个块,在这之中定义的所有变量在代码块外都是不可见的,我们称之为块级作用域。 

针对d:?

针对e: 

全局的可以用,全局的不用捕捉 

10.4 函数对象与lambda表达式 

函数对象,又称为仿函数,即可以想函数一样使用的对象,就是在类中重载了operator()运算符的 类对象。 

<code>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表达式完全一样。

 函数对象将rate作为其成员变量,在定义对象时给出初始值即可,lambda表达式通过捕获列表可 以直接将该变量捕获到。

 实际在底层编译器对于lambda表达式的处理方式,完全就是按照函数对象的方式处理的,即:如 果定义了一个lambda表达式,编译器会自动生成一个类,在该类中重载了operator()。

 Lambda在用法上本质是一个匿名函数对象

Lambda被编译后生成一个特殊名字(lambda_uuid的格式)的类对象/仿函数

十一  包装器 

11.1function包装器 

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

那么我们来看看,我们为什么需要function呢? 

<code>//ret = func(x);

// 上面func可能是什么呢?那么func可能是函数名?函数指针?函数对象(仿函数对象)?也有可能

//是lamber表达式对象?所以这些都是可调用的类型!如此丰富的类型,可能会导致模板的效率低下!

//为什么呢?我们继续往下看

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;

}

通过上面的程序验证,我们会发现useF函数模板实例化了三份。 

包装器可以很好的解决上面的问题 

std::function在头文件<functional>

// 类模板原型如下

template <class T> function; // undefined

template <class Ret, class... Args>

class function<Ret(Args...)>;

模板参数说明:

Ret: 被调用函数的返回类型

Args…:被调用函数的形参

 function<返回值类型(对应函数形参...)>

// 使用方法如下:

#include <functional>

int f(int a, int b)

{

return a + b;

}

struct Functor

{

public:

int operator() (int a, int b)

{

return a + b;

}

};

class Plus

{

public:

static int plusi(int a, int b)

{

return a + b;

}

double plusd(double a, double b)

{

return a + b;

}

};

int main()

{

// 函数名(函数指针)

std::function<int(int, int)> func1 = f;

cout << func1(1, 2) << endl;

// 函数对象

std::function<int(int, int)> func2 = Functor();

cout << func2(1, 2) << endl;

// lamber表达式

std::function<int(int, int)> func3 = [](const int a, const int b)

{return a + b; };

cout << func3(1, 2) << endl;

// 类的成员函数

std::function<int(int, int)> func4 = &Plus::plusi;

cout << func4(1, 2) << endl;

std::function<double(Plus, double, double)> func5 = &Plus::plusd;

cout << func5(Plus(), 1.1, 2.2) << endl;

return 0;

}

有了包装器,如何解决模板的效率低下,实例化多份的问题呢?

用function封装起来,只需实例化一个useF函数就可以解决

#include <functional>

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

{

// 函数名

std::function<double(double)> func1 = f;

cout << useF(func1, 11.11) << endl;

// 函数对象

std::function<double(double)> func2 = Functor();

cout << useF(func2, 11.11) << endl;

// lamber表达式

std::function<double(double)> func3 = [](double d)->double { return d /

4; };

cout << useF(func3, 11.11) << endl;

return 0;

}

PS :自用补充

取成员函数的指针要用&(静态可不用

普通成员函数有个隐含的this,但this不能显示传,我们该怎么传过去呢?

答:我们可以传函数指针过去,也可以传类对象过去;

疑问:不是传指针吗,怎么可以传对象过去

解答:要从底层来看,function不是将参数直接传给plusd调用,它是接收到这个函数指针后,在内部把他作为一个成员变量进行储存,之后调operator(),在operator()中再调用可调用对象,无论是pd还是Plus()都可以调用plusd这个函数((this不能显示传,所以也符合这个规则)

11.2 bind 

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

<code>// 原型如下:

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

 简化功能:

1. 调整参数顺序 

2. 调整参数个数

PS:使用前得展开placeholders命名空间 或者 placeholders::_1,_2....以此类推 

十二 线程库

挖坑ing


总结

✨✨✨各位读友,本篇分享到内容是否更好的让你理解C++11,如果对你有帮助给个👍赞鼓励一下吧!!

🎉🎉🎉世上没有绝望的处境,只有对处境绝望的人。

感谢每一位一起走到这的伙伴,我们可以一起交流进步!!!一起加油吧!!



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。