C++11新特性详解

Posted The August

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++11新特性详解相关的知识,希望对你有一定的参考价值。

C++11新特性详解

C++11简介

相比于C++98/03,C++11则带来了数量可观的变化,其中包含了约140个新特性,以及对C++03标准中约600个缺陷的修正,这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言,C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全,不仅功能更强大,而且能提升程序员的开发效率。

列表初始化

{}初始化

在C++98中,标准允许使用花括号对数组元素进行统一的列表初始值设定。

struct Point

 	int _x;
 	int _y;
;
int main()

 	int array1[] =  1, 2, 3, 4, 5 ;
 	int array2[5] =  0 ;  //0 0 0 0 0 
 	Point p =  1, 2 ;  //运用了struct结构体的语法     初始化
 	return 0; 
 

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

struct Point

	int _x;
	int _y;

	Point(int x, int y)
		:_x(x)
		, _y(y)
	
;

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

	
	Point p =  1, 2 ;
	//Point p 1, 2 ;
	
	Point* p3 = new Point[3] 1, 1,  2, 2 ,  3, 3  ;

	int* p1 = new int(0);
	int* p2 = new int[5]1,2,3,4,5;  
	//C++11中 new可以初始化数组

	//自定义类型的列表初始化
	Date d1(2022, 3, 13);
	Date d2 =  2022, 3, 15 ;
	Date d3 2022, 3, 15 ;
	Date2022,3,15;

	int i = 1;
	int j =  2 ;
	int k 3 ;
	return 0;

总结:

  • C++11里面扩展了初始化使用,基本都可以使用它来初始化
  • 但是建议还是按旧的用法来使用,一般new[]建议使用它来初始化

std::initializer_list

模拟实现的vector支持初始化和赋值:

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

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

class A

public:
	A(int a, double d, int b)
		:_a(a)
		, _d(d)
		, _b(b)
	
private:
	int _a;
	double _d;
	int _b;
;
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()

	//内置类型的列表初始化
	vector<int> v1 =  1, 2, 3, 4, 5 ;
	vector<int> v2 1, 2, 3, 4, 5 ;
	//vector (initializer_list<value_type> il,const allocator_type& alloc = allocator_type());


	auto lt1 = 1, 2, 3, 4;
	initializer_list<int> lt2 =  1, 2, 3, 4 ;
	//auto=initializer_list<int>


	map<string, int> dict1 =  pair<string, int>("sort", 1), pair<string, int>("insert", 2) ;
	map<string, int> dict2 =   "sort", 1 ,  "insert", 2  ;
	//首先 "sort", 1 ,  "insert", 2 创建成initializer_list<map<string,int>>类型的对象
	//最后map (initializer_list<value_type> il,const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type());
	//这个构造函数初始化dict2


	//自定义类型的列表初始化
	Date d1(2022, 3, 13);
	Date d2 =  2022, 3, 15 ;
	Date d3 2022, 3, 15 ;
	Date 2022, 3, 15 ;


	
	A aa1 =  1, 1.11, 1;
	list<A> lt =   1, 1.11, 1,  2, 2.22, 1 ;
	//首先  1, 1.11, 1,  2, 2.22, 1 创建成initializer_list<list<A>>类型的对象(首先是A类得有相应的构造函数才行)
	//最后list的构造函数初始化it
	return 0;

总结:

  • 一个自定义类型调用初始化,本质是调用对应的构造函数
  • 自定义类型对象可以使用初始化,必须要要有对应参数类型和个数的构造函数
  • STL容器支持初始化,容器支持一个initializer_list作为参数的构造函数

声明

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

auto(在C++中不支持C语言中原来auto的用法)

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

int main()

	int i = 10;
	auto p = &i;
	
	auto pf = strcpy;
	//输出p、pf的类型
	cout << typeid(p).name() << endl;
	cout << typeid(pf).name() << endl;
	
	map<string, string> dict =  "sort", "排序", "insert", "插入" ;
	//map<string, string>::iterator it = dict.begin();
	
	auto it = dict.begin();
	
	return 0;

注意: typeid(变量、对象).name()得到的结果是字符串,这个是不能 当作类型的

decltype

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

// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2)

	decltype(t1 * t2) ret = t1 * t2;
	vector<decltype(t1* t2)> v;
	v.push_back(ret);
	cout << typeid(ret).name() << endl;


int main()

	int i = 10;
	auto p = &i;
	auto pf = strcpy;
	decltype(pf) pf1;    //char * (__cdecl*)(char *,char const *)
	vector<decltype(pf)> v;

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

	return 0;

注意:decltype与auto的差别:auto必须要求显式初始化,而decltype没要求

nullptr

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

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

范围for循环

见手撕STL系列

STL中一些变化


arrary

注意:

  • a1、a2没什么太大区别,他俩都是从栈上开辟空间的
  • a1越界时会报错(assert断言)、而a2是抽查(越界不一定报错)

forward_list

  • forward_list就是单链表
  • forward_list中支持向后插入(insert_after)、向后删除(erase_after)不支持向前删除和插入(效率太低)
  • forward_list支持单向迭代器

unordered_set、unordered_map
【手撕STL】unordered_set、unordered_map(用哈希表封装)

容器中的一些新方法

  • 基本每个容器中都增加了一些C++11的方法,但是其实很多都是用得比较少的。比如提供了cbegin和cend方法返回const迭代器等等,但是实际意义不大,因为begin和end也是可以返回const迭代器的,这些都是属于锦上添花的操作。
  • 实际上C++11更新后,容器中增加的新方法最后用的插入接口函数的右值引用版本:
  • 针对旧容器,基本都增加移动构造,移动赋值所有插入数据接口,都增加右值引用版本,这些接口都是用来提高效率的

右值引用和移动语义

注意:图中和代码上所写的移动拷贝改为移动构造

左值引用和右值引用

传统的C++语法中就有引用的语法,而C++11中新增了的右值引用语法特性,无论左值引用还是右值引用,都是给对象取别名。

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

int main()

	// 以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;


	//	可以取地址
	cout << &p << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &(*p) << endl;
	
	b = c;
	
	// 以下几个是对上面左值的左值引用
	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);
	
	//	// 不能取地址
	//	cout << &10 << endl;
	//	cout << &(x+y) << endl;
	//	cout << &fmin(x, y) << endl;
	
	// 这里编译会报错:error C2106: “=”: 左操作数必须为左值
	//10 = 1; 
	//x + y = 1;
	//fmin(x, y) = 1;
	return 0;

需要注意的是右值是不能取地址的,但是给右值取别名后,会导致右值被存储到特定位置,且可
以取到该位置的地址,也就是说例如:不能取字面量10的地址,但是rr1引用后,可以对rr1取地
址,也可以修改rr1。如果不想rr1被修改,可以用const int&& rr1 去引用

int main()

	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;
	rr1 = 20;
	int& rr = rr1;
	//rr2 = 5.5;  // 报错
	return 0;

注意:左值引用可以连续左值引用,而右值引用是不可以连续右值引用的(右值引用后该变量为左值,不能使用右值引用了)

左值引用与右值引用比较

左值引用总结:

  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以后的左值。
int main()

	// 右值引用只能右值,不能引用左值
	int&& r1 = 10;

	// error C2440: “初始化”: 无法从“int”转换为“int &&”
	// message : 无法将左值绑定到右值引用
	int a = 10;
	//int&& r2 = a;  //报错 右值引用只能右值,不能引用左值
	// 右值引用可以引用move以后的左值
	int&& r3 = move(a);
	return 0;

总结:

  • 左值引用可以取地址,左值基本都可以出现赋值符号左边也可以出现赋值符号右边,可以修改,但是const修饰的左值,只能获取地址,不能赋值
  • 右值不能出现赋值符号的左边,只能出现在右边,也就是不能修改,右值不能取地址
  • 本质上引用都是用来减少拷贝,提高效率
    1. 左值引用解决大部分的场景。(做参数、做返回值)
    1. 右值引用是左值引用一些盲区的补充。

右值引用使用场景和意义

右值引用可以补齐左值引用的短板

namespace lc

	class string
	
	public:
		typedef char* iterator;
		iterator begin()
		
			return _str;
		

		iterator end()
		
			return _str + _size;
		

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		
			//cout << "string(char* str)" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		

		// s1.swap(s2)
		void swap(string& s)
		
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		

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

			string tmp(s._str);
			swap(tmp);
		

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		
			cout << "string(string&& s) -- 移动拷贝" << endl;

			//this->swap(s);
			swap(s);
		

		// 赋值重载
		string& operator=(const string& s)
		
			cout << &#

以上是关于C++11新特性详解的主要内容,如果未能解决你的问题,请参考以下文章

C++11新特性详解

C++11新特性详解

C++11新特性总结

C++11新特性:10—— C++11 tuple元组详解

c++11新特性:变长参数模板详解

C++11新特性:18—— C++11 long long超长整形详解