【C++】C++11第一篇-创新互联

• C++11简介
• 列表初始化
• • 花括号的初始化问题
  • 内置类型的初始化列表
  • 多个对象的列表初始化
• 变量类型推导
• • auto
  • decltype
• 默认成员函数控制
• • 显式缺省函数
  • 删除默认函数
• 右值引用
• • 右值引用的基本概念
  • 右值引用存在的必要性
  • • 移动语义
    • 右值引用引用左值
    • 完美转发
  • 右值引用作用

相比于C++98/03，C++包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好的用于系统开发和库开发、语法更加泛化和简单化、更加稳定和安全，功能更加强大，很好的提高了其使用者的开发效率。

在C++98标准中，允许使用"{}"对数组元素进行统一的列表初始值设定。但是对于自定义类型，却无法进行这样的初始化。相对于C++98而言，C++11扩大了用花括号括起的列表（初始化列表）的使用范围，使其可用于所有内置类型和用户自定义的类型的列表初始化，使用初始化列表时，可添加等号，也可不添加。

void main()
{//内置类型变量
	int x = 10;
	int y{10 };
	int z = {10 };
	int i = 1 + 2;
	int n = {1 + 2 };
	int m{1 + 2 };

	//数组
	int arr1[3]{55,66,77 };
	int arr2[]{55,66,77 };

	//动态数组 C++98中不支持
	int* arr = new int[3]{55,66,77 };

	//标准容器
	vectorv{11,22,33 };
	mapm{{1,1},{2,2},{3,3} };
}

列表初始化可以在花括号前使用等号，不使用也可以，两者没有什么区别。

void main()
{int *ptr = new int[10]{1,2,3,4,5,6,7,8,9,10 };
	delete[]ptr;
}

ptr是数组指针，也就是指向数组的指针，我们在堆上面开辟了一段空间，最后记得进行释放，释放的时候，ptr的类型要写对，带中括号。

相较于C++98，C++11支持多个对象的列表初始化，因为C++底层提供了一个类模板，即initializer_list，并对内置类型提供了initializer_list类型参数的构造函数。initializer_list是系统自定义的类模板，该类模板中主要有三个方法：begin()、end()迭代器以及获取区间中元素个数的方法size()。

对于自定义类，如果想要该类支持列表初始化，只需要给该类添加一个带有initializer_list类型参数的构造函数。

class Pointer
{public:
	Pointer():m_x(0),m_y(0)
	{}
	Pointer(initializer_listlist)
	{m_x = *list.begin();
		auto  it = list.end();
		--it;
		m_y = *it;
	}
	Pointer(int x,int y):m_x(x),m_y(y)
	{}
public:
	int m_x;
	int m_y;
};

void main()
{listlt = {1,2,3,4,5 };//内置容器的列表初始化
	Pointer p = {1,2 };//自定义类型的列表初始化
}

在定义变量时，必须要先给出变量的实际类型，才能定义变量，因为定义变量需要开辟栈空间，所以必须确定类型以确定开辟的大小空间。

但是在很多情况下，我们可能不知道实际类型怎么给出，或者实际类型特别复杂，直接给出类型特别麻烦，于是就有了变量类型推导这回事儿。

C++11中，可以使用auto来根据变量初始化表达式类型推导变量的实际类型。

void main()
{mapm;
	map::iterator it = m.begin();

	auto it1 = m.begin();
}

it1和it的类型相同，且使用起来并没有什么不同，但是很显然，用auto自动推导it1的类型比直接定义要简洁方便许多。

auto使用的前提是，必须对auto声明的变量进行初始化，否则编译器无法推导出auto的实际类型，但很显然，这样有其局限性，比如我们的变量需要根据表达式完成之后结果的类型进行推导，因为编译期间，代码不会运行，此时auto就不能满足我们的需求，于是运行时类型识别（RTTI）就应运而生了。

在C++98中，确实已经支持了RTTI：

• typeid只能查看类型不能用其结果类定义类型
• dynamic_case只能用于含有虚函数的继承体系中

不过运行时类型识别有其缺陷，会降低程序运行的效率。

decltype是根据表达式的实际类型推演出定义变量时所用的类型。

• 推演表达式类型作为变量的定义类型

void main()
{int a = 1;
	double b = 1.23;

	decltype(a + b) c;
	cout<< typeid(c).name()<< endl;
}

c的定义就是用decltype推演出a+b这个表达式的实际类型来定义的，auto是做不到这一点的。

• 推演函数返回值的类型

int GetMax(int x, int y)
{return x >y ? x : y;
}
void main()
{cout<< typeid(decltype(GetMax)).name()<< endl;//A句
	cout<< typeid(decltype(GetMax(9, 8))).name()<< endl;//B句
}

执行结果：

int __cdecl(int,int)
int

A句不带参数，就是推导函数的类型；B句带参数列表，推导的就是函数返回值的类型，要注意的是，B句只是进行类型推演，并不会执行函数。

在C++11中，可以在默认函数定义或者声明时加上“=default”，从而显式的指示编译器生成该函数的默认版本，用“=default”修饰的函数称为显式缺省函数。

class Test
{public:
	Test() = default;
	//无参构造函数
	Test(const Test&) = default;
	//显式生成默认的拷贝构造函数
	Test& operator=(const Test&) = default;
	~Test() = default;
	Test(int d):m_data(d)
	{}
private:
	int m_data;
};
void main()
{Test t;
}

如果要限制某些默认函数的生成，在C++11中，只需要在函数声明加上“=delete”即可，我们称“=delete”修饰的函数称为删除函数。

C++98中提出了引用的概念，很大的提高了程序的可读性，引用就是别名，引用变量与其引用实体共用一块内存空间，引用的底层是通过指针来实现的，避免了我们直面指针。

为了提高程序的运行效率，C++11中引入了右值引用，右值引用也是起别名，但是只能对右值进行引用。与右值相对的是左值，我们要右值引用，第一个问题就是得弄清楚什么是右值。

一般情况下，我们认为可以放在等号左边的，能够取地址的称为左值，只能放在右边的，或者说不能取地址的称为右值，但是这样区分太笼统了，不一定完全正确。

C++1对右值进行了严格的区分：

• C语言中的纯右值，比如a+b、10
• 将亡值。典型的就是表达式的中间结果，函数按照值的方式返回的值。

void main()
{int a = 10;
	int &b = a;//引用
	const int &c = 10;//常引用
	int &&d = 10;//右值引用
}

10是右值，具有常性，要引用10，有两种办法，第一种就是常引用，加const；第二种就是右值引用，右值引用有两个&符号。

10是一种符号，该符号本身并不具备空间，这也就是为什么普通引用会报错，左值引用必须加const的原因，我们说引用是起别名，起别名的前提是地址空间存在，这样才能给一块空间起别名，这也就可以理解为什么普通引用不能引用10，加上const之后，我们会开辟一段临时空间，并用10对这段空间进行初始化，常引用引用的是这块空间。

对于这种本身是一种符号常量的，C++11引入了右值引用专门来引用他们。同样的，右值引用也会开辟空间，并用10进行初始化，右值引用这块开辟的空间。

对将亡值的右值引用：

int fun(int a, int b)
{int result = a + b;
	return result;
}
void main()
{int res = fun(1, 2);
	//int &res1 = fun(1, 2);编译不能通过
	int &&res2 = fun(1, 2);
	const int &res3 = fun(1, 2);
}

首先我们需要明白的是，fun函数最后得到的计算结果result是一个临时变量，生存作用域仅限于fun函数的函数体内部，出了函数体，result就会被销毁，那我们是怎么得到函数返回值的呢？我们会创建一个临时变量，这个临时变量被result初始化，保存了函数的返回值，这个临时变量会去初始化我们的res，res就是我们接收函数返回值的变量。

需要注意的是，我们之所以能用右值去引用函数返回值，是因为我们上面介绍的那个充当result和res之间的桥梁的临时变量是具有常性的，它的常性决定了它是右值，可以用右值引用。

普通引用只能引用左值，不能引用右值，const引用既可以引用左值，又可以引用右值。

C++11中右值引用：只能引用右值，一般情况下不能直接引用左值。

如果一个类涉及到资源管理，用户必须显式提供拷贝构造、赋值运算符的重载以及析构函数，否则系统自己生成的默认的函数会造成浅拷贝，造成程序崩溃。这种浅拷贝和深拷贝的问题我们之前用String类详细的分析过，今天String类做一个例子，我们看一下它对"+"的重载函数：

class String
{public:
	String(const char *str = ""):m_data(nullptr)
	{cout<<"Create Obj : "<cout<<"Copy Create Obj : "<//移动构造
		cout<<"Move Create Obj : "<cout<<"Assign Obj : "<	char *new_data = new char[strlen(s.m_data)+1];
			strcpy(new_data, s.m_data);
			delete []m_data;
			m_data = new_data;
		}
		return *this;
	}
	~String()
	{cout<<"Free Obj : "<	delete []m_data;
			m_data = nullptr;
		}
	}
public:
	String operator+(const String &s)
	{cout<<"operator+"<

我们在上面解释了函数给调用者返回执行结果时生成临时对象的问题，对于上述加法的重载也是一样的，按照值的方式返回，一定会拷贝构造一个临时对象，临时对象在创建好之后，new_str就会被销毁，创建的临时对象和new_str内容完全相同，但是却拥有不同的地址空间，这对于空间来说是一种浪费，同时程序的效率也会降低，而且临时对象的作用不算很大，就相当于建立了一个桥梁，用于过渡。

那这种情况怎么优化呢？此时就到右值引用登场了。

int main()
{String s("Hello");
	String s1("world");
	String s2 = s + s1;
	return 0;
}

String(String &&s)
	{//移动构造
		m_data = s.m_data;
		s.m_data = nullptr;
	}

int main()
{String s1("Hello");
	String s2(s1);//拷贝构造
	String s3(move(s1));//移动构造
	return 0;
}

void Fun(int &x)
{cout<< "lvalue ref"<< endl;
}
void Fun(int &&x)
{cout<< "rvalue ref"<< endl;
}
void Fun(const int &x)
{cout<< "const lvalue ref"<< endl;
}
void Fun(const int &&x)
{cout<< "const rvalue ref"<< endl;
}

templatevoid PerfectForward(T &&t)
{Fun((t));
}

int main()
{PerfectForward(10); // rvalue ref

	int a;
	PerfectForward(a); // lvalue ref
	PerfectForward(std::move(a)); // rvalue ref

	const int b = 8;
	PerfectForward(b); // const lvalue ref
	PerfectForward(std::move(b)); // const rvalue ref

	return 0;
}

lvalue ref
lvalue ref
lvalue ref
const lvalue ref
const lvalue ref

void PerfectForward(T &&t)
{Fun(forward(t)); 
}

rvalue ref
lvalue ref
rvalue ref
const lvalue ref
const rvalue ref