新的类功能

explicit隐式类型转换

1. 自动类型转换可能会导致意外转换的问题，为解决该问题，C++引入了关键字explicit以禁止单参数构造函数导致的自动转换

class Plebe
{
public:
	explicit Plebe(double y);
};
Plebe b = 0.2;  //不允许，会直接报错

class Plebe
{
public:
	Plebe(int x);
	explicit Plebe(double y);
};
Plebe a = 1;  //正确，没问题
Plebe b = 0.2;  //不报错，但是会调用Plebe(int x)的构造函数

2. C++11拓展了explicit的这种用法，使得对转换函数做类似的处理

class Plebe
{
public:
	Plebe();  //默认构造
	explicit operator double() const;  //转换函数Plebe转为double
};
Plebe a;
double x = a;  //报错

类内初始化

1. C++11增加了类内成员初始化的功能：

class Sension
{
private:
	int m_a = 10;   //类内成员初始化
	double m_b{ 20.5 };  //类内成员初始化
	short m_c;
public:
	Sension() {}
	Sension(short c) :m_c(c){}
	Sension(int a, double b, short c):m_a(a), m_b(b),m_c(c){}
};

（1）类内成员初始化的效果与使用与使用初始化列表相同
（2）如果构造函数在成员初始化列表中提供了相应的值，这些类内成员初始化的值将被覆盖

特殊的成员函数

1. C++11在原有4个特殊的成员函数:默认构造函数、复制构造函数、复制赋值运算符、析构函数的基础上，新增了两个特殊的成员函数：移动构造函数、移动赋值运算符，这些成员函数由编译器自动提供
2. 若用户没有提供任何构造函数，编译器将提供默认构造函数，称为默认的默认构造函数
3. 若用户没有提供复制构造函数/移动构造函数，而代码又需要使用它，编译器将提供一个默认的复制构造函数/移动构造函数
4. 若用户没有提供复制赋值运算符/移动赋值运算符，而代码又需要使用它，编译器将提供一个默认的复制赋值运算符/移动赋值运算符
5. 若用户提供了复制构造函数或复制赋值运算符，编译器不会自动提供移动构造函数和移动赋值运算符
6. 若用户提供了移动构造函数或移动赋值运算符，编译器不会自动提供复制构造函数和复制赋值运算符

class A
{
public:
    A()
    {
        cout << "A()" << endl;
    }
    A(A&& obj)
    {
        cout << "A(A&& obj)" << endl;
    }
};
A a1;
A a2 = a1;  //报错

7. 默认的移动构造函数和移动赋值运算符的工作方式与默认的复制构造函数和默认的复制赋值运算符类似:
   （1）执行逐成员初始化并复制内置类型
   （2）如果成员是类对象，将使用相应类的构造函数和赋值运算符，就像参数为右值一样，如果定义了移动构造函数和移动赋值运算符，就调用它们，否则调用复制构造函数和复制赋值运算符(因为const A & 可以引用右值)

默认的方法和禁用的方法

1. 使用default关键字显式地声明特殊成员方法的默认版本，即加上default关键字后，你自己不提供编译器也会帮你提供

class SomeClass
{
public:
    SomeClass() = default;  //去掉default后编译器报错
    SomeClass(const SomeClass && obj){}
};
SomeClass sc;   //不会报错，因为编译器提供了默认构造函数

2. 使用关键字delete可以禁止编译器使用特定的方法

class SomeClass
{
public:
    SomeClass() = default;  //去掉default后编译器报错
    SomeClass(SomeClass && obj) = delete;
    SomeClass&  operator=(SomeClass && obj) = delete;
	SomeClass(const SomeClass & obj){}
	SomeClass & operator=(const SomeClass& obj )
	{
		return *this;
	}
};

3. default只能用于6个特殊的成员函数，而delete可以用于任何成员函数

class SomeClass
{
public:
	void redo(int) = delete;
	void redo(double);
};
SomeClass sc;
sc.redo(5);   //报错

委托构造函数

1. C++11允许在一个构造函数的定义中使用另一个构造函数，称为委托，即该构造函数暂时将创建对象的工作委托给另一个构造函数

class SomeClass
{
public:
	SomeClass(int a, float b, string c):m_a(a), m_b(b),m_c(c)
	{}
	SomeClass():SomeClass(0, 2.0, "hello"){}
};

继承构造函数

1. C++11提供了一种让派生类能够继承基类的构造函数的机制
2. 派生类继承基类所有的构造函数(默认构造函数、复制构造函数和移动复制构造函数除外)，但不会使用与派生类构造函数特征标匹配的构造函数

class BC
{
public:
	BC(int a, double  b):m_a(a), m_b(b)
	{}
	BC(double b):BC(0, b){}
	BC():BC(0, 2.0){}
private:
	int m_a;
	double m_b;
};
class DC : public BC
{
public:
	using BC::BC;
	DC(double c):m_c(c)
	{
	}
private:
	double m_c;
};
DC dc(1, 2.3);   //调用BC的构造函数
DC dc(1);  //调用DC的构造函数

管理虚方法

1. 当派生类重写基类的虚方法时，若函数特征标不同，则会隐藏基类的虚方法，而不是重写(覆盖)
2. C++11提供override指出要覆盖一个虚方法，将其放在参数列表后面(在派生类里面)，如果申明与基类方法不匹配，编译器将视为错误

class BC
{
public:
	virtual void show(char ch) 
	{
		cout << ch << endl;
	}
};
class DC : public BC
{
public:
	virtual void show(char* ch) override  //编译器报错:char * 不为char 
	{
		cout << ch << endl;
	}
};

3. 若想禁止派生类覆盖特定的虚方法，可在此参数列表后面加上final

class BC
{
public:
	virtual void show(char ch) final
	{
		cout << ch << endl;
	}
};
class DC : public BC
{
public:
	virtual void show(char* ch)  //编译器报错：“无法重写final函数”
	{
		cout << ch << endl;
	}
};

3. override和final并非关键字，而是具有特殊意义的标识符