C++11的更新介绍

于 2024-08-16 21:39:20 发布
阅读量532 收藏 6
点赞数 10
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80468112/article/details/141232132
版权

7.3 完美转发

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

template<class T>
void PerfectForward(T&& t)
{
	
}

就是说如果传的是左值他就是左值引用，如果传的是右值它就是右值引用。

用 typeid 是查看不了的，它只会打出你本来的类型

55df67d503bf437f8469af9312db2f51.png

那么能不能通过函数调用来查看 ？

949a2d433b4a41c5894f56df9d51d48e.png

查看不了

因为模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力， 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值。

如果希望能够在传递过程中保持它的左值或者右值的属性, 就需要用到完美转发。

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

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<class T>
void PerfectForward(T&& t)
{
	Fun(forward<T>(t));
}

int main()
{

	PerfectForward(10);//右值
	int a = 10;
	PerfectForward(a);//左值


	const int b = 10;
	PerfectForward(b);//const 左值
	PerfectForward(move(b));// const 右值
	return 0;
}

dcb03532c8384de3b3148be062c030dd.png

完美转发实际中的使用场景：

	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _date;

		ListNode(const T& pos = T())
			:_date(pos)
		{
			_next = nullptr;
			_prev = nullptr;
		}

		ListNode(T&& pos)
			:_date(move(pos))
		{
			_next = nullptr;
			_prev = nullptr;
		}

	};	

	template<class T>
	class list
	{

	public:
		typedef ListNode<T> node;
		list()
			:_head(new node)
		{
			_head->_next = _head;
			_head->_prev = _head;
		}

        void push_back(T&& x)
		{
			//Insert(_head, x);
			Insert(_head, std::forward<T>(x));
		}

		void Insert(node* pos, T&& x)
		{
			node* prev = pos->_prev;
			node* newnode = new node(move(x));//因为T的类型在创建这个类的时候就已经确定，所            
                                              //以可以直接 move(),也可以使用完美转发
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}

		iterator insert(iterator pos, const T& x)
		{
			node* newnode = new node(x);
			node* next = pos._node;
			node* last = next->_prev;
			last->_next = newnode;
			newnode->_prev = last;
			newnode->_next = next;
			next->_prev = newnode;
			return iterator(newnode);
		}

	private:
		node* _head;
	};

8 新的类功能

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

1. 构造函数

2. 析构函数

3. 拷贝构造函数

4. 拷贝赋值重载

5. 取地址重载

6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。

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

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

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

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

3143945227844f418ea2660ce55ecf01.png

f0e11a97243e48a0ba22e21a1c28cdcc.png

需要显示写析构，说明有资源需要释放

1、说明需要显示写拷贝构造和赋值重载

2、说明需要显示写移动构造和移动赋值

一般情况下编译器默认生成的移动构造是没有什么意义的。但是如上面的person 类，则就很有意义因为里面有一个自定义类型的成员他写了移动构造，person 类自动生成的移动构造就会调用自定义类型成员的移动构造。

所以看似移动构造默认生成的条件苛刻，实际是合理的，因为这三个函数（析构函数 、拷贝构造、拷贝赋值重载）本来就是一体的。

类成员变量初始化

初始化列表：

以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟
一个放在括号中的初始值或表达式。

 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

所有的成员你可以在初始化列表初始化也可以在函数体内初始化但是下面三种成员，必须放在初始化列表位置进行初始化：

  • 引用成员变量
  • const成员变量
  • 自定义类型成员(且该类没有默认构造函数时)

2e684dbfa666531651f9c44db5f8cd60.png

如果放到函数体则会报错 

518a6c9bb74a26d42e734f4899e29cad.png

const 变量有一个特点就是必须在定义的时候初始化 ，因为const 变量只有一次初始化的机会，

而每个成员定义的的地方在初始化列表。

引用成员变量也必须在定义时初始化，总不能定义一个不知道是谁的别名吧！

4662d073181f8c7345eb7c48922990f5.png

042da9e584d485f394c3132e5c0cb26d.png

 所以初始化列表本质可以理解为每个对象中成员定义的地方。

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，
一定会先使用初始化列表初始化。

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

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

6d37004333fe424e9cd144d7098c7097.png

编译器会觉得这些函数是一体的所以要一起写出来。

33a67d869b144a82998b58c4b39a1a4f.png

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

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

不想让拷贝则可以加一个delete

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}

	//自己生成移动构造和拷贝构造

	Person(const Person& p) = delete;

private:
	bit::string _name;
	int _age;
};

在C++98没有delete时可以如下操作：

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}


	//只声明不实现， 声明为私有
private:
	Person(const Person& p);
	Person& operator=(const Person& p);

private:
	bit::string _name;
	int _age;
};

io流就是一个不想被拷贝的类。

template <class ...Args>
void ShowList(Args&&... args)//传左值变左值引用，传右值变右值引用
{}

9 可变参数模板

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

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

名字是随便取的

eb637fcae453480fa05bb513638b2712.png

template <class ...Args>
void ShowList(Args&&... args)//传左值变左值引用，传右值变右值引用
{}

597bd567318d4c86a515d15f87215fda.png

可变模板参数 = 参数类型可变 && 参数个数可变

37f58e5fea1f462f9b27cabc3d6dd729.png

08f0d52fec94441286ad813689d6b82e.png

2bffb39ace614345bbeb488405b2d40a.png

这样写是错误的，C语言的可变参数底层是类似这样的方式支持的，但是C++不行。C语言取可变参数是在运行时去取，而C++ 可变模板参数是在编译时，要解析每个参数。而for 循环是运行时获取和解析，所以这样是走不通的。

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

方式1 

编译时递归推导解析

void print()
{
	cout << endl;
}

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

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{
	print(args...);
}

int main()
{
	ShowList();
	ShowList(1);
	ShowList(1, "11111");
	ShowList(1, "11111", 3);
}

a69951fcd4d84695ba72d4adc476d637.png

编译器底层的逻辑就像下面这样

void print()
{
	cout << endl;
}

//template <class T, class ...Args>
//void print(T t, Args... args)
//{
//	cout << t << " ";
//	print(args...);
//}

void print(int a)
{
	cout << a << " ";
	print();
}

void print(const char* s, int a)
{
	cout << s << " ";
	print(a);
}

void print(int i, const char* s, int a)
{
	cout << i << " ";
	print(s, a);
}

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
//template <class ...Args>
//void ShowList(Args... args)
//{
//	print(args...);
//}

void ShowList(int i, const char * s, int a)
{
	print(i, s, a);
}

int main()
{
	//ShowList();
	//ShowList(1);
	//ShowList(1, "11111");
	ShowList(1, "11111", 3);
}

84e41034ddb64f3bb5c57b62038049e8.png

可变参数模板帮助我们省略了很多模板。

方式2

逗号表达式展开参数包

这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

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, "11111");
	ShowList(1, "11111", 3);
}

也可以用这种写法：与上面是等价的。

template <class T>
int PrintArg(T t)
{
	cout << t << " ";
	return 0;
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { PrintArg(args)... };
	cout << endl;
}
int main()
{
	ShowList(1);
	ShowList(1, "11111");
	ShowList(1, "11111", 3);
}

我们像下面可以这样理解。 

04692c8020624e9f9a6e67b36c300704.png

还可以这样写：

template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { (cout<<args<<" ", 0)...};
	cout << endl;
}
int main()
{
	ShowList(1);
	ShowList(1, "11111");
	ShowList(1, "11111", 3);
}

a0e17c072b23440086d9872fe1651a87.png

emplace_back 的使用及实现

int main()
{
	list<bit::string> l1;

	bit::string s1("111111");
	l1.emplace_back(s1);

	//l1.emplace_back(s1, s1, s1);//虽然它是可变参数模板但是它不支持插入多个值

	l1.emplace_back(move(s1));

	return 0;
}

那么emplace_back 使用可变模板参数有什么用呢？

可以直接传list<T> T对象的参数包，直接用参数包构造T

int main()
{
	list<pair<bit::string, int>> l2;
    //构造pair 拷贝/移动构造pair 到list节点的data 上
	pair<bit::string, int> p1("苹果", 1);
	l2.emplace_back(p1);
	l2.emplace_back(move(p1));

	l2.emplace_back("苹果", 1);


	return 0;
}

拷贝构造和赋值重载改成下面那样了更好观察

		// 拷贝构造
		// s2(s1)
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}


		// 赋值重载
		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;
		}

	
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _date;

		template<class... Args>
		ListNode(Args&&... args)
			:_date(forward<Args>(args)...)
		{
			_next = nullptr;
			_prev = nullptr;
		}
	};

	template<class T>
	class list
	{

	public:
    	template<class... Args>
		void emplace_back(Args&&... args)
		{
			insert(end(), forward<Args>(args)...);
		}

		template<class... Args>
		iterator insert(iterator pos, Args&&... args)
		{
			node* newnode = new node(forward<Args>(args)...);
			node* next = pos._node;
			node* last = next->_prev;
			last->_next = newnode;
			newnode->_prev = last;
			newnode->_next = next;
			next->_prev = newnode;
			return iterator(newnode);
		}

	private:
		node* _head;
	};

这里用完美转发的原因还是因为如果传的右值，还是会退化为左值。

感谢大家的观看！

fy zs
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言中文网C++11教程
08-16
C++11是C++编程语言的一个重要更新，它引入了大量的新特性，旨在提升效率、安全性和可读性。以下是一些从提供的压缩包文件名中提炼出的关键知识点的详细解释： 1. **可变参数模板（Variadic Templates）**：在`9C++...
深入理解c++11 pdf
05-26
《深入理解C++11》一书探讨了C++11标准的新特性和改进，旨在帮助程序员更好地理解和利用这些更新。在第三章“通用为本，专用为末”中，作者着重介绍了继承构造函数的概念，这是一个针对代码复用和简化派生类构造函数...
C++11：lambda表达式
Man9o
03-09 1万+
通常lambda表达式用于封装一些传递给算法或异步函数的代码。C++11中引入了λ表达式，它可以用来定义一个**内联 (inline)**的函数，作为一个本地的对象或者一个参数。内联函数是一种编译器优化技术，它可以避免函数调用的开销，提高执行效率。λ表达式可以被编译器自动内联展开，从而减少函数调用的次数。但是，并不是所有的λ表达式都会被内联，这取决于编译器的实现和优化策略。
c++11新特性介绍
终曲
11-09 1万+
文章目录介绍语言优化template 表达式内的空格右值引用nullptr 和 std::nullptr_t 介绍 （维基百科）C++11，先前被称作C++0x，即ISO/IEC 14882:2011，是C++编程语言的一个标准。它取代第二版标准ISO/IEC 14882:2003（第一版ISO/IEC 14882:1998公开于1998年，第二版于2003年更新，分别通称C++98以及C++03...
C++编程语言中string类介绍
热门推荐
liitdar的博客
08-21 31万+
string类是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和C语言的字符串之间有着良好的接口。
C++基本介绍
Dirty_artist的博客
05-23 2447
C++基本介绍
C++11
修行的凡人的博客
11-15 3253
基于著名书籍和自我学习得出的C++11新特性
C++的介绍与认识
最新发布
2302_79376097的博客
07-10 2763
学习了C语言的知识，今天小编将进军C++的知识，本篇博客可能略微枯燥，主要是对C++的相关介绍和认识，以及学习路线，下节将正式进入C++的学习。C++起源于C语言，但通过引入面向对象编程（OOP）和泛型编程的特性，使其功能更为丰富和灵活。它被广泛应用于系统/应用程序开发、游戏开发、嵌入式系统等领域，因其性能优越和可扩展性而受到程序员的青睐。
C++11入门基础
2021dragon的博客
09-04 3581
在2003年C++标准委员会提交了一份技术勘误表（简称TC1），使得C++03这个名字取代了C++98成为C++11之前的最新C++标准名称。但由于C++03主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把这两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准姗姗来迟。
详解C++11
拾至名瑰的博客
12-11 2314
每日一句：请不要相信，胜利就像山坡上的蒲公英一样唾手可得。但是请相信，世上总有一些美好值得我们全力以赴，哪怕粉身碎骨！正文开始！在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++11，实用方法介绍（一）
2201_75373858的博客
04-12 916
c++11实用方法初步介绍（花括号的使用，声明方面，新增容器等）
C++11新特性详解
AI_ELF的博客
07-23 8647
相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。thread在线文档说明stdreturn0。...
C++11特性简单介绍
08-31
### C++11 特性详解 #### 一、`auto`关键字 ...这些特性共同构成了C++11的重要更新，它们不仅提高了代码的可读性和可维护性，还使得C++语言更加现代化。通过学习和掌握这些新特性，开发者可以更高效地编写C++程序。
C++11最新使用手册
01-22
该文档为 C++11 标准的早期草稿版本，旨在为 C++ 开发者提供全面的更新指南，帮助理解并掌握 C++11 的新特性和改进之处。 #### 三、文档主要内容 - **1. General 一般性介绍** - **1.1 Scope 范围**：定义了 C++...
C++11 多线程
09-23
**C++11** 是C++语言的一个重要更新版本，它引入了许多新特性来简化编程流程并增强其功能。其中一项重要的新增功能就是**多线程支持**。在**C++11** 之前，尽管可以通过第三方库如Boost.Thread实现多线程编程，但...
C++11新特性.rar
03-11
C++11是C++编程语言的一个重大更新，它在2011年被正式采纳为ISO标准。这个版本引入了大量的新特性，旨在提高代码的效率、可读性以及安全性。下面将详细介绍C++11的一些核心新特性。 1. **自动类型推断（Auto关键字...
电子书 深入理解C++11（PDF）
02-04
C++11是C++语言的一个重大更新，它带来了许多新的功能和优化，使得C++在效率、可读性和安全性方面都有了显著提升。这本书以通俗易懂的语言解释了这些变化，让读者能够迅速适应并利用新标准进行更高效、更现代的编程...
c++11特征.docx
10-23
C++11是C++编程语言的一个重要更新，引入了许多新特性和改进，极大地提升了语言的效率和可读性。以下是一些C++11的关键特性： 1. **auto 关键字**：在C++11中，`auto`关键字用于类型推断，取代了原来的指定存储期的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值