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 = 0;
    }

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

void Class_test(){
    int m = 0;
    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 = 0;
}

static void Person_test01(){
    m_B = 10;
}
void Person_Class_test(){
    int m = 0;
    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 = 10;
    Person p1(m);
    Person p2(m);

    //---------
    //30
    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 = 0; //加了mutable，可以修改
    }

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



};

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