this指针/常函数、常对象

this指针引入

　　类中对象的成员变量和成员函数是分开存储的，sizeof(空class) = 1，另外示例中涉及到字节对齐的问题，double本身的字节为8，int为4，由于字节对齐，int也为8，所以最终字节数为16

 class Person{
     int m; //非静态成员变量，属于对象  sizeof(Person) = 4
     static int n;  //静态成员变量，不属于对象 sizeof(Person) = 4
     static void func();  //静态成员函数，不属于对象 sizeof(Person) = 4
     void func01();  //非静态成员函数，不属于对象 sizeof(Person) = 4
     double p;  //sizeof(Person) = 16 字节对齐 #pragma pack(1)可以取消字节对齐
 };

 void test01(){
     cout << "sizeof(Person) = " << sizeof(Person) << endl;
 }

　　非静态成员变量才属于对象本身，静态成员变量、函数、非静态成员函数（非内联）不属于对象本身。

　　每一个非内联成员函数只会诞生一份函数实例，多个同类型对象会共用一块代码，由于类中每个实例后的对象都有独一无二的地址，因此不同的实例对象调用成员函数时，函数需要知道是谁在调用它，因此引入了this指针。

this指针原理

　　主要作用：为了区分不同的实例对象；解决命名冲突。

　　this指针是隐含在对象成员函数内的一种指针。当一个对象被创建后，它的每一个成员函数都会含有一个系统自动生成的隐含指针this。this指针指向被调用的成员函数所属的对象（谁调用成员函数，this指向谁），*this表示对象本身，非静态成员函数中才有this，静态成员函数内部没有。

 class Person{
 public:
     static int m_B;
     int m_A;

     Person(int tmp){
         m_A = tmp;
     }

     void test(){
         m_A = ;
     }

     static void test01(){
         m_B = ;
     }
 };

 void Class_test(){
     int m = ;
     Person p(m);
 }

　　编译器对上述代码进行如下处理，对非静态成员函数默认添加了this指针，类型为class *cosnt this

 struct Person{
     static int m_B;
     int m_A;
 };

 void Person_Ini(Person *const this, int tmp){ //添加了this指针
     this->m_A = tmp;
 }
 void Person_test(Person *const this){
     this->m_A = ;
 }

 static void Person_test01(){
     m_B = ;
 }
 void Person_Class_test(){
     int m = ;
     Person p;
     Person_Ini(&p, m);

 }

this指针使用

　　一般多用于：（1）当形参与成员变量名相同时，用this指针来区分；（2）在类的非静态成员函数中返回对象本身，可以用return *this，this指向对象，*this表示对象本身。

 class Person{
 public:
     int m_A;

     Person(int m_A){
         this->m_A = m_A; //为了区分形参和成员变量同名
     }

     //PPlus返回对象可以实现链式编程，如果没引用则返回的是this指向对象的拷贝
     Person& PPlus(Person p){
         this->m_A += p.m_A;
         return *this; //返回对象
     }

 };

 void test01(){
     int m = ;
     Person p1(m);
     Person p2(m);

     //---------
     //
     p1.PPlus(p1).PPlus(p1);
     //---------

     //---------
     //40
     //p1.PPlus(p1);
     //p1.PPlus(p1);
     //---------

     cout << p1.m_A << endl;
 }

空指针访问成员函数 

　　注意：（1）如果成员函数没有用到this，则空指针可以直接访问；（2）若成员函数用到了this，则可以加if判断，如果this为NULL，则直接return掉。

 常函数、常对象

void func() const //常函数

const Person p2; //常对象

　　常函数修饰的是this指针，不允许修改this指针指向的值，如果执意要修改常函数，可以在成员属性前加mutable。

　　常对象不允许修改属性，不可以调用普通成员函数，可以调用常函数。

 class Person{
 public:
     int m_a;
     mutable int m_b;

     void test() const{
         //this->m_a = 100; //加了const表示常函数，不可修改this指向的值，其实也是成员属性
         this->m_b = ; //加了mutable，可以修改
     }

     void test02() {
         this->m_a = ; //
         this->m_b = ; //加了mutable，可以修改
     }

 };

 void test01(){
     const Person p;
     //p.m_a = 10; //常对象，不可修改属性值
     p.test();
     //p.test02(); //不可调用普通函数
 }