C++旅程第六站------this指针

这是她

Little by little,one travels far.        

           this指针-------指向被调用的成员函数所属对象
          1、this指针是隐含每一个非静态成员函数内的一种指针；
          2、this指针不需要定义，直接使用即可；

         this指针的用途：
        1、当形参和成员变量同名时，可用this指针来区分；
        2、在类的非静态成员函数中返回对象本身，可用return *this;

1. #include<iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class Meat
   
6. {
   
7.         public:
   
8.                 int price;
   
9.                
   
10.                 Meat(int price)
    
11.                 {
    
12.                         //当形参和成员变量同名时，可用this指针来区分；
    
13.                         this->price = price;
    
14.                 }
    
15.                
    
16.                 Meat& MeatAddprice(Meat r)
    
17.                 {
    
18.                         this->price += r.price;
    
19.                         //返回对象本身
    
20.                         return *this;
    
21.                 }
    
22. };
    
23. 
    
24. int main()
    
25. {
    
26.         Meat pork(45);
    
27.         cout << "The price of pork : " << pork.price << endl;
    
28.         
    
29.         Meat beef(56);
    
30.         beef.MeatAddprice(pork);
    
31.         beef.MeatAddprice(pork).MeatAddprice(pork).MeatAddprice(pork).MeatAddprice(pork);//如果希望这条语句可以顺利运行，那么这个成员函数的返回值类型应该是对象，所以嘞，我们在这返回引用，而不是返回一个值
    
32.         cout << "The price of beef is : " << beef.price << endl;
    
33.         
    
34.         return 0;
    
35. }

复制代码

         const修饰成员函数

         常函数：
         1、成员函数后加const----该成员函数->常函数；
         2、常函数内不可以修改成员属性；
         3、成员属性声明时加关键字mutable-----在常函数中依然可以修改；

        常对象：
        1、声明对象前加const----该对象->常对象；
        2、常对象只能调用常函数；

1. #include<iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class Meat
   
6. {
   
7.         public:
   
8.                 int m_price;
   
9.                 int m_mass;
   
10.                 mutable int m_size; //加入mutable关键字，即使在常函数中也可以修改他的值
    
11.                
    
12.                 Meat(int price,int mass)
    
13.                 {
    
14.                         this->m_price = price;
    
15.                         this->m_mass = mass;
    
16.                 }
    
17.                
    
18.                 //this指针的本质--指针常量，指针的指向是不可以修改的
    
19.                 //在成员函数后面加const，修饰的是this的指向，让指针指向的值也不可以修改
    
20.                 void showmass(int mass) const
    
21.                 {
    
22.                         this->m_size = 888;//这个语句是可以执行的
    
23.                         this->m_mass = 999;//如果成员函数没有const，这条语句是可以执行的；加入const以后，指针指向的值是不可以修改的
    
24.                         this->m_mass = NULL;//this指针是不可以修改指针的指向的
    
25.                         cout << "Eating meat!!!!!!" << endl;
    
26.                 }
    
27.                
    
28.                 void showprice()
    
29.                 {
    
30.                         //防止空指针
    
31.                         if(this == NULL)
    
32.                         {
    
33.                                 return;
    
34.                         }
    
35.                        
    
36.                         cout << "price : " << this->m_price << endl;
    
37.                 }
    
38.                
    
39. };
    
40. 
    
41. int main()
    
42. {
    
43.         Meat *pork = NULL;
    
44.         pork->showmass(555);
    
45.         //pork->showprice();//传入空指针会出错
    
46.        
    
47.         const Meat beef(1,1);//在对象前面加入const，变成常对象
    
48.         beef.m_price = 666;//不可以修改
    
49.         beef.m_size = 333;//可以修改
    
50.        
    
51.         //常对象只能调用常函数
    
52.         beef.showmass(555);//√
    
53.         beef.showprice(222,111); //×  常对象不可以调用普通成员函数，因为普通成员函数可以修改属性
    
54.        
    
55.        
    
56.         return 0;
    
57. }

复制代码

                                         渣渣等待大佬赐教