C++11特性--新的类功能--特殊的成员函数(移动构造函数，移动赋值运算符),默认方法和禁用方法(default,delete),委托构造函数,管理虚方法(override,final)

Love The Way You Lie 2021-12-15 07:29 130阅读 0赞

**1.新的类功能  
（1）特殊的成员函数  
\*在原有4个特殊成员函数（默认构造函数，复制构造函数，复制赋值运算符和析构函数）的基础上，C++11新增了两个：移动构造函数，移动赋值运算符。这些成员函数式编译器在各种情况下自动提供的。  
\*如果类定义了移动构造函数或移动赋值运算符，编译器将不会自动提供复制构造函数和复制赋值运算符  
\*如果类定义了造函数，复制构造函数或析构函数，编译器将不会自动提供移动构造函数和移动赋值运算符  
  
  
（2）默认的方法和禁用的方法  
\*由于某种原因，编译器不会自动提供某些方法。例如，类定义了移动构造函数，编译器将不会自动创建默认的构造函数，复制构造函数和复制赋值构造函数。这时，可以用default关键字显示地声明这些方法的默认版本  
\*default关键字只能用于6个特殊的成员函数  
Example：  
 class A**

**\{**

**private:**

**int x;  
public:  
A() = default;  
A(int i):x(i)  
\{  
\}  
  
\};  
  
  
int main()  
\{  
A a;//ok**

**return 0;**

**\}  
  
  
（3）关键字delete可以禁止编译器使用特定方法**

**\*delete可用于任何成员函数**

**Example:**

**class A  
\{  
public:  
void fun(int x )  
\{  
cout<<x<<endl;  
\}  
  
void fun(double x) = delete; //禁止double类型的转换  
 \};  
  
  
 int main()  
 \{   
 A a;  
 a.fun(1);//1 ok  
//a.fun(1.1);//error, use of deleted function 'void A::fun(double)'  
  
 return 0;  
 \}  
  
  
(4)委托构造函数  
C++11允许在一个构造函数的定义中使用另一个构造函数，这被称为委托。  
Example:  
 class A  
\{  
private:  
int x;  
int y;  
int z;  
public:  
A(int i,int j,int k):x(i),y(j),z(k)\{ \}  
A(int i,int j):A(i,j,0)\{ \}  
A(int i):A(i,0,0)\{ \}  
A():A(0,0,0)\{ \}  
void fun()  
\{  
cout<<x<<ends<<y<<ends<<z<<ends;  
\}  
\};  
  
  
int main()  
\{  
A a;  
a.fun();//0 0 0  
 cout<<endl;  
  
 A b(1);  
 b.fun();//1 0 0  
 cout<<endl;  
  
 A c(1,2);  
 c.fun();//1 2 0  
 cout<<endl;  
  
 A d(1, 2, 3);  
 d.fun();//1 2 3  
  
 return 0;  
 \}  
  
(5)管理虚方法：override和final  
\*使用虚说明符override指出要覆盖的函数：将其放在参数类别后面。如果与基类方法不匹配，编译器将视为错误  
 class base  
 \{   
 public:  
 virtual void fun()  
 \{   
 cout<<"base::fun()"<<endl;  
 \}  
 \};  
  
  
 class derived:public base  
 \{   
public:  
virtual void fun() override  
\{   
cout<<"derived::fun()"<<endl;  
\}  
 \};  
  
  
 int main()  
 \{   
derived d;  
d.fun();  
  
return 0;  
 \}  
  
output:  
derived::fun()  
  
  
\*final:禁止派生类覆盖特定的虚方法  
Example:  
 class A  
\{  
public:  
 virtual void fun()  
 \{  
 cout<<"A::fun()"<<endl;  
 \}  
\};  
  
class B:public A  
\{  
public:  
 virtual void fun() override final  // 禁止B的派生类覆盖特此虚方法  
 \{  
 cout<<"B::fun()"<<endl;  
 \}  
\};  
  
class C:public B  
\{  
public:  
virtual void fun() override // error, overriding final function 'virtual void B::fun()'  
 \{   
cout<<"C::fun()"<<endl;  
 \}  
 \};**