C++对象模型和this指针

1、成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上

1.1、空类大小

class MyPeople
{
};
void Class_Func_Constructor_Member()
{
    MyPeople p1;
    cout << "空对象占用的内存空间为： " << sizeof(p1) << " 字节"<< endl;
}

运行结果：

C++ 会为每个空对象分配一个字节的内存空间，是为了区分空对象占内存的位置。每个空对象都有一个独一无二的地址

1.2、非空类大小

class MyPeople07
{
public:
    int m_a;//非静态成员变量，属于类的对象上，计算类对象大小时需要计算

    static int m_b;//静态成员变量，不属于类的对象上，计算类对象大小时不需要计算

    void func()  //非静态成员函数，不属于类的对象上 ，计算类对象大小时不需要计算
    {

    }

    static void func2()  //静态成员函数，不属于类的对象上 ，计算类对象大小时不需要计算
    {

    }

};
void Class_Func_Constructor_Member()
{
    MyPeople07 p2;
    cout << "非空对象占用的内存空间为： " << sizeof(p2) << " 字节" << endl;
}

运行结果：

1.3、结论

由此可知，在类中，只有非静态成员变量才属于类的对象上，在计算类对象大小时，只需要考虑非静态成员变量的种类和个数。

2、this指针概念

在C++中成员变量和成员函数是分开存储的。每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

问题：这一块代码是如何区分那个对象调用自己的呢？
c++通过提供特殊的对象指针，this指针，解决上述问题。
（1）this指针指向被调用的成员函数所属的对象
（2）this指针是隐含每一个非静态成员函数内的一种指针
（3）this指针不需要定义，直接使用即可

this指针的用途：
（1）当形参和成员变量同名时，可用this指针来区分。解决名称冲突
（2）在类的非静态成员函数中返回对象本身，可使用return

2.1、解决名称冲突

当形参和成员变量同名时，可用this指针来区分
this指针 指向 被调用的成员函数 所属的对象

class MyPeople08
{
public:
    MyPeople08(int age)
    {
        this->age = age;

    }
   int age;
};
void Class_Func_Constructor_this_ptr()
{
    //解决名称冲突
    MyPeople08 p1(10);
    cout << "p1 AGE : " << p1.age << endl;
}

运行结果：

2.2、在类的非静态成员函数中返回对象本身，可使用return *this

class MyPeople09
{
public:
    MyPeople09(int age)
    {
        this->age = age;
    }
    MyPeople09& PeopleAddAge(MyPeople09 &p)
    {
        this->age += p.age;
       
        return *this; //this 是指向对象的指针，*this就是对象本身
    }
   int age;
};
void Class_Func_Constructor_this_ptr()
{
    //返回对象本身用 *this
    MyPeople09 p1(10);
    cout << "p1 AGE : " << p1.age << endl;
    
    MyPeople09 p2;
    p2.PeopleAddAge(p1);
    cout << "p2 AGE : " << p2.age << endl;
}

运行结果：

2.3、拷贝构造函数返回值为引用的时候，可进行链式编程

class MyPeople08
{
public:
    MyPeople08(int age)
    {
        this->age = age;
    }

    MyPeople08& PeopleAddAge(MyPeople08 &p)
    {
        this->age += p.age;
        return *this;
    }

    int age;
};
void Class_Func_Constructor_this_ptr()
{
    MyPeople08 p1(10);
    cout << "p1 AGE : " << p1.age << endl;

    MyPeople08 p2(10);
    cout << "p2 AGE : " << p2.age << endl;

    //链式调用
    p2.PeopleAddAge(p1).PeopleAddAge(p1).PeopleAddAge(p1);
    cout << "链式调用后 p2 AGE : " << p2.age << endl;
}

运行结果：

注意：当拷贝构造函数返回值为类名时，结果如下：

原因：
MyPeople08 对象 作为返回值会触发编译器提供的浅拷贝，返回的对象跟原来的对象不是同一块内存；
MyPeople08 & 对象 作为返回值，那么接收的变量就是原来对象的一个别名，操纵同一块内存
链式调用目的是 在原数据改变的基础上 递增 ，引用是地址传递 会改变原有的值，不用引用就变成复制操作了

3、空指针访问成员函数

class MyPeople09
{
public:
    void ShowClassName()
    {
        cout << "This is MyPeople09 class !" << endl;
    }

    void ShowPeopleAge()
    {
        cout << "age = " << this->m_Age << endl;
    }

    int m_Age;
};

3.1、访问ShowClassName()成员函数

void Class_Func_Constructor_nullptr_func()
{
    MyPeople09 *p1 = NULL;
    p1->ShowClassName();
}

运行结果：

3.2、访问ShowPeopleAge()成员函数

void Class_Func_Constructor_nullptr_func()
{
    MyPeople09 *p1 = NULL;
    p1->ShowPeopleAge();
}

报错！！！

因为对于传入的指针为NULL函数来说，
其中的 cout << "age = " << m_Age << endl;相当于 cout << "age = " << this->m_Age << endl; 默认会自动加上this指针
此时，调用该函数时，传入的指针为NULL，再通过NULL->m_Age访问，就会出现问题。

修改方式如下：
在传入的指针为NULL函数中增加对空指针的判断即可

 void ShowPeopleAge()
    {
        //解决方式：增加对空指针的判断
        if (this == NULL)
        {
            return;
        }
        cout << "age = " << this->m_Age << endl;
    }

4、const修饰成员函数

4.1、常函数

成员函数后加const后我们称为这个函数为常函数

特性：
1、常函数内不可以修改成员属性
2、成员属性声明时加关键字mutable后，在常函数中依然可以修改

4.1.1、 常函数本质是对this指针的修改

this指针的本质是一个 “指针常量”( MyPeople10 * const this )，表示：指针的指向不可修改；
在常函数中，该指针被进一步限定为 ： const MyPeople10 * const this 表示：指针的指向不可修改并且指向的内容不能被修改。
此时，如果通过this指针修改成员变量的值，编译器会报错：不可修改的左值。如图：

4.1.2、成员属性声明时加关键字mutable后，可在常函数中修改

4.2、常对象

声明对象前加const 称该对象为 常对象

void Class_Func_Constructor_const_func()
{
    const MyPeople10 p1; 	//在对象前加 const 即为 常对象
    //p1.m_A = 123;  		//不可修改普通成员变量
    p1.m_B = 789;        	//mutable特殊变量，在常对象中可以修改值

    p1.ShowMyPeople10Class();  //常对象只能调用常函数
    p1.func();  //
}

常对象只能调用常函数