深入学习c++(类的c++11后三个基本原则变成了五个基本原则）

东方耀

//深入学习c++(类的c++11后三个基本原则变成了五个基本原则）
//c++11中可以严格区分左值与右值！
//对于一个带有资源的类 深拷贝的  
//原则：1、构造new析构delete 2、拷贝构造函数 3、operator=重载  
//     4、[针对右值]拷贝构造函数 5、[针对右值]operator=重载

C++中的类 ：绝对不要在析构函数里面抛出异常
所以：默认的析构函数都添加了关键字 noexcept
原因：
1、C++无法同时捕获多个异常 一个try{}catch{}只能一个异常
   A、多个实例 或 B、多个基类的析构抛异常
2、导致类的有些资源无法释放，内存泄露


c++(类 构造函数失败应该抛出异常）

1. #include <iostream>
   
2. #include <vector>
   
3. #include <string.h>
   
4. #include <cassert>
   
5. 
   
6. using namespace std;
   
7. 
   
8. class Teacher
   
9. {
   
10. private:
    
11.     int m_age;
    
12.     char* m_name;  //字符指针 资源
    
13. public:
    
14.     Teacher(int age, char* pname){
    
15.         m_age = age;
    
16.         m_name = new char[strlen(pname) + 1];
    
17.         strcpy(m_name, pname);
    
18.     }
    
19.     void print_info() const{
    
20.         assert(m_name);
    
21.         printf("老师的年龄：%d，名字：%s\n", m_age, m_name);
    
22.     }
    
23.     Teacher(const Teacher& other){
    
24.         //拷贝构造函数 Teacher& other 不带const就只能是左值的拷贝构造了
    
25.         printf("调用拷贝构造函数,不带const就只能是左值的！\n");
    
26.         m_age = other.m_age;
    
27.         m_name = new char[strlen(other.m_name) + 1];
    
28.         strcpy(m_name, other.m_name);
    
29. 
    
30.     }
    
31.     Teacher(Teacher&& other){
    
32.         //【右值的】拷贝构造函数
    
33.         printf("调用【右值的】拷贝构造函数！\n");
    
34.         // 右值一般都是临时变量 操作完后就不用了的 利用右值减少拷贝
    
35.         m_age = other.m_age;
    
36.         m_name = other.m_name;
    
37.         other.m_name = nullptr;
    
38.         other.m_age = -1;
    
39. 
    
40.     }
    
41.     Teacher& operator=(const Teacher& other){
    
42.         printf("调用operator=重载,不带const就只能是左值的！\n");
    
43.         m_age = other.m_age;
    
44.         delete [] m_name;   //先释放左边的资源
    
45.         m_name = new char[strlen(other.m_name) + 1];
    
46.         strcpy(m_name, other.m_name);
    
47.         return *this;
    
48.     }
    
49. 
    
50.     Teacher& operator=(Teacher&& other){
    
51.         //Teacher&&代表是右值的引用
    
52.         printf("调用【右值的】operator=重载！\n");
    
53.         if(&other == this){
    
54.             // t1 = std::move(t1);这种情况下
    
55.             return *this;
    
56.         }
    
57.         
    
58.         delete [] m_name;  //记得先释放左边的资源
    
59.         // m_name = new char[strlen(other.m_name) + 1];
    
60.         // strcpy(m_name, other.m_name);
    
61.         m_name = other.m_name;
    
62.         m_age = other.m_age;
    
63.         other.m_name = nullptr;
    
64.         other.m_age = -1;
    
65.         return *this;
    
66.     }
    
67. 
    
68.     ~Teacher(){
    
69.         printf("调用老师%s析构函数！\n", m_name);
    
70.         delete [] m_name;
    
71.         m_age = -1;
    
72.     }
    
73. };
    
74. 
    
75. //深入学习c++(类的c++11后三个基本原则变成了五个基本原则）
    
76. //c++11中可以严格区分左值与右值！
    
77. //对于一个带有资源的类 深拷贝的  
    
78. //原则：1、构造new析构delete 2、拷贝构造函数 3、operator=重载  
    
79. //     4、[针对右值]拷贝构造函数 5、[针对右值]operator=重载
    
80. 
    
81. 
    
82. int main(){
    
83.     Teacher t1(30, "jingjinju");
    
84.     Teacher t2(33, "izengzhi");
    
85.     // c++11中严格区分了 左值与右值   能取地址的就是左值
    
86.     //std::move(t1) 就是将左值转为右值  
    
87.     // 编译器有能力区分 左值还是右值的 拷贝构造函数  operator=
    
88.     Teacher t3 = std::move(t1);
    
89.     //特别注意：std::move()调用之后 t1的m_name变null了 t1的资源已经被抽干了
    
90.     // t1.print_info();
    
91.     t1 = std::move(t2);
    
92.     return 0;
    
93. }
    
94. 
    
95. 
    

复制代码

zouqiqi

让天下人人学会人工智能！人工智能的前景一片大好！