C++笔记4.56

知识点1 可重载的运算符

知识点2 重载自增或者自减运算符++ — 运算符

operator++

编译器看到++a(前置++)，就调用operator++(a)，当编译器看到a++(后置++)，就会调用operator++(a,int)

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Data  
6. {  
7.     friend ostream& operator<<(ostream &out,Data &ob);  
8. private:  
9.     int a;  
10.     int b;  
11. public:  
12.     Data()  
13.     {  
14.         cout << "无参的构造函数" << endl;  
15.         a = 0;  
16.         b = 0;  
17.     }  
18.   
19.     Data(int a, int b):a(a),b(b)  
20.     {  
21.         cout << "有参构造函数" << endl;  
22.     }  
23.   
24.     void showData(void)  
25.     {  
26.         cout << "a = " << a << " b = " << b << endl;  
27.     }  
28.   
29.     //++ob1  
30.     //编译器默认识别operator++(a)，但是a可以用this代替，从而化简  
31.     Data& operator++()  
32.     {  
33.         a++;  
34.         b++;  
35.         return *this;  
36.     }  
37.   
38.     //ob1++  
39.     Data& operator++(int)  
40.     {  
41.         static Data tmp_data = *this;  
42.   
43.         a++;  
44.         b++;  
45.         return tmp_data;  
46.     }  
47.   
48.     Data& operator--()  
49.     {  
50.         a--;  
51.         b--;  
52.         return *this;  
53.     }  
54.   
55.     Data& operator--(int)  
56.     {  
57.         static Data tmp_data = *this;  
58.         a--;  
59.         b--;  
60.         return tmp_data;  
61.     }  
62.   
63.     ~Data()  
64.     {  
65.         cout << "析构函数" << endl;  
66.     }  
67. };  
68.   
69. ostream& operator<<(ostream &out,Data &ob)  
70. {  
71.     out << "a = " << ob.a << " b = " << ob.b << endl;  
72.     return out;  
73. }  
74.   
75. int main()  
76. {  
77.     Data ob1(10,20);  
78.     ob1.showData();  
79.     cout << ++ob1;  
80.     Data ob2(15,25);  
81.     cout << ob2++;  
82.     cout << ob2;  
83.     Data ob3(20,30);  
84.     cout << --ob3;  
85.     Data ob4(25,35);  
86.     cout << ob4--;  
87.     cout << ob4;  
88.     return 0;  
89. }  

知识点3 重载指针运算符*->实现智能指针

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Person  
6. {  
7. private:  
8.     int num;  
9. public:  
10.     Person(int num):num(num)  
11.     {  
12.         cout << "有参构造" << endl;  
13.     }  
14.   
15.     void showPerson(void)  
16.     {  
17.         cout << "num = " << num << endl;  
18.     }  
19.   
20.     ~Person()  
21.     {  
22.         cout << "析构函数" << endl;  
23.     }  
24. };  
25.   
26. //设计一个智能指针解决堆区空间的释放问题  
27. class SmartPointer  
28. {  
29. public:  
30.     Person *pPerson;  
31. public:  
32.     SmartPointer(Person *p)  
33.     {  
34.         pPerson = p;  
35.     }  
36.   
37.     ~SmartPointer()  
38.     {  
39.         if (pPerson != NULL)  
40.         {  
41.             delete pPerson;  
42.             pPerson = NULL;  
43.         }  
44.     }  
45.   
46.     //重载->运算符  
47.     Person* operator->()  
48.     {  
49.         return this->pPerson;  
50.     }  
51.   
52.     //重载*运算  
53.     Person& operator*()  
54.     {  
55.         return *(this->pPerson);  
56.     }  
57. };  
58.   
59. int main()  
60. {  
61.     Person *p = new Person(100);  
62.     p->showPerson();  
63.     //需要手动写delete p才能够释放空间，容易造成内存泄漏  
64.     delete p;  
65.     //使用智能指针  
66.     SmartPointer pointer(new Person(200));  
67.     //访问person类中的方法  
68.     //pointer.pPerson->showPerson();  
69.   
70.     //(pointer.operator -> ())->showPerson();  
71.     pointer->showPerson();  
72.   
73.     (*pointer).showPerson();  
74.   
75.     return 0;  
76. }