C++笔记4.36

知识点3 静态成员 static修饰的成员

为什么要使用static修饰静态成员函数

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Data  
6. {  
7. private:  
8.     int num;//普通成员变量  
9.     static int data;//静态成员变量（类内声明）  
10. public:  
11.     //普通的成员函数依赖于对象，必须调用  
12.     int getData(void)  
13.     {  
14.         return data;  
15.     }  
16.     //静态成员函数属于类而不属于对象  
17.     static int setStaticData(void)  
18.     {  
19.         return data;  
20.     }  
21. };  
22. //类外定义时不需要加static  
23. int Data::data = 100;//类外定义+初始化  
24.   
25. int main()  
26. {  
27.     //cout << Data::data << endl;//报错，静态data是私有的，类外不能够直接访问  
28.     //cout << Data::getData() << endl;//报错，getData必须通过成员对象调用  
29.     Data ob;  
30.     cout << ob.getData() << endl;  
31.     //出现的问题：data是静态的，在创建对象之前就已经存在了  
32.     //如果没有实例化对象，难道就无法使用data了吗  
33.     //为了解决以上问题，需要使用到静态成员函数  
34.     //1.静态成员函数属于类，可以直接通过类名称访问  
35.     cout << Data::setStaticData() << endl;  
36.     //2.也可以通过对象名称访问 对象共享静态成员函数  
37.     cout << ob.setStaticData() << endl;  
38. }  

注意事项

1、静态成员函数的目的在于操作静态成员数据

2、静态成员函数不能够直接访问非静态成员数据（静态成员函数内部没有this指针）

3、普通成员函数可以操作静态成员数据和非静态成员数据

4、静态成员变量和静态成员函数都有权限之分

使用const修饰的静态成员

如果一个类的成员既要实现共享，又要实现不可被改变，就要使用static const修饰

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Data  
6. {  
7. public:  
8.     const static int data;  
9.     static int getDataStatic(void)  
10.     {  
11.         return data;  
12.     }  
13. };  
14.   
15. const int Data::data = 100;  
16.   
17. int main()  
18. {  
19.     //可以访问  
20.     cout << Data::data << endl;  
21.     //Data::data = 200;//data静态成员只读  
22.     cout << Data::data << endl;  
23. }  

知识点4 静态成员的使用案例

使用静态成员统计类实例化的对象的个数

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Data  
6. {  
7. public:  
8.     static int count;  
9.   
10.     Data()  
11.     {  
12.         cout << "无参构造" << endl;  
13.         count++;  
14.     }  
15.   
16.     Data (const Data &ob)  
17.     {  
18.         cout << "拷贝构造函数" << endl;  
19.         count ++;  
20.     }  
21.   
22.     ~Data()  
23.     {  
24.         count --;  
25.         cout << "析构函数" << endl;  
26.     }  
27. };  
28.   
29. int Data::count = 0;  
30.   
31. int main()  
32. {  
33.     Data ob1;  
34.     Data ob2;  
35.     Data ob3;  
36.     {  
37.         Data ob4;  
38.         Data ob5;  
39.         cout << "对象的个数：" << Data::count << endl;  //5
40.     }  
41.     cout << "对象的个数：" << Data::count << endl;  //3
42.     return 0;  
43. }  

设计单例模式 只能实例化一个对象，还要借助公共的方法拿到这个地址

第一步：在单例类内部定义一个Singleton类型的静态对象，作为外部共享的唯一实例

第二步：提供一个公共静态的方法，让客户可以访问它的唯一实例

第三步：为了防止在外部对实例化其他对象，将其默认构造函数和拷贝构造函数设计为私有

C++笔记4.35

知识点5 this指针（重点）

C++的封装性将数据和方法封装在一起，但是数据和方法是分开存储的，每一个对象都拥有独立的数据，但是共享同一个方法。

当一个对象去调用成员函数的时候，系统会自动把对象的地址赋值给this指针，this指针指向外部调用成员方法的对象。

隐式转换

1. m_num = num;//编写的代码  
2. this -> m_num = num;//实际运行时的代码  

具体实例

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Data  
6. {  
7. public:  
8.     int m_num;  
9.   
10.     void setNum(int num)  
11.     {  
12.         this -> m_num = num;  
13.     }  
14. };  
15.   
16. int main()  
17. {  
18.     Data ob1;  
19.     ob1.setNum(10);  
20.     cout << "ob1.m_num = " << ob1.m_num << endl;  
21.   
22.     Data ob2;  
23.     ob2.setNum(20);  
24.     cout << "ob2.m_num = " << ob2.m_num << endl;  
25.   
26.     Data ob3;  
27.     ob3.setNum(30);  
28.     cout << "ob3.m_num = " << ob3.m_num << endl;  
29. }  

注意事项

1、this指针是隐含在对象成员函数内的一种指针

2、成员函数通过this指针可以知道操作的说哪个对象的数据

3、静态成员函数内部没有this指针，静态成员函数属于类的内部。静态成员函数不能操作非静态成员变量。

知识点6 this指针的使用

当形参和成员变量同名时，可用this指针来区分

1. class Data  
2. {  
3. public:  
4.     int num;  
5.   
6.     //形参和成员名相同  
7.     void setNum(int num)  
8.     {  
9.         //num = num;//由于就近原则，形参num赋值给形参num  
10.         //将形参num赋值给对象成员num  
11.         this -> num = num;  
12.     }  
13. };  

在类的普通成员函数中返回对象本身（*this）（重要）

1. #include <iostream>  
2. #include <string>  
3.   
4. using namespace std;  
5.   
6. class MyCout  
7. {  
8. public:  
9.     MyCout& myCout(char *str)  
10.     {  
11.         cout << str;  
12.         return *this;//*this代表的就是当前该函数调用的对象  
13.     }  
14. };  
15.   
16. int main()  
17. {  
18.     MyCout ob;  
19.     //原来的输出方式  
20.     /*ob.myCout("Mo");  
21.     ob.myCout("Mo");  
22.     ob.myCout("Ka");*/  
23.   
24.     ob.myCout("Mo").myCout("Mo").myCout("Ka");  
25.   
26.     return 0;  
27. }