详解类与对象——c++对象模型和this指针-CSDN博客

在这里插入图片描述

（^ _ ^）

一.成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

class Person {

public:

    Person() {

        mA = 0;

    }

    //非静态成员变量占对象空间

    int mA;

    //静态成员变量不占对象空间

    static int mB;

    //函数也不占对象空间，所有函数共享一个函数实例

    void func() {

        cout << "mA:" << this->mA << endl;

    }

    //静态成员函数也不占对象空间

    static void sfunc() {

    }

};

  

int main() {

  

    cout << sizeof(Person) << endl;

  

    system("pause");

  

    return 0;

}

只有非静态成员变量占对象空间
补充：
空对象占用的内存空间是：1；
原因：区分空对象占用内存的位置，每个空对象也都有一个独一无二的地址

二.this指针的概念

我们知道在C++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
c++通过提供特殊的对象指针，this指针，解决区分哪个对象调用自己的问题。
this指针指向被调用的成员函数所属的对象

1.特点：

this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可

2.用途：

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

class Person

{

public:

  

    Person(int age)

    {

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

        this->age = age;

    }

  

    Person& PersonAddPerson(Person p)

    {

        this->age += p.age;

        //返回对象本身

        return *this;

    }

  

    int age;

};

  

void test01()

{

    Person p1(10);

    cout << "p1.age = " << p1.age << endl;

  

    Person p2(10);

    p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);

    cout << "p2.age = " << p2.age << endl;

}

  

int main() {

  

    test01();

  

    system("pause");

  

    return 0;

}

输出结果为：
p1=10;
p2=40;
（或者将成员变量命名为m_age也可以达到和this指针一样的目的）

三. 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性(
if( this ==NULL)
{
return ;
}

//空指针访问成员函数

class Person {

public:

  

    void ShowClassName() {

        cout << "我是Person类!" << endl;

    }

  

    void ShowPerson() {

        if (this == NULL) {

            return;

        }

        cout << m_Age << endl;

    }

  

public:

    int m_Age;

};

  

void test01()

{

    Person * p = NULL;

    p->ShowClassName(); //空指针，可以调用成员函数

    p->ShowPerson();  //但是如果成员函数中用到了this指针，就不可以了

}

  

int main() {

  

    test01();

  

    system("pause");

  

    return 0;

}

四.const修饰成员函数

常函数：

成员函数后加const后我们称为这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数

class Person {

public:

    Person() {

        m_A = 0;

        m_B = 0;

    }

  

    //this指针的本质是一个指针常量，指针的指向不可修改

    //如果想让指针指向的值也不可以修改，需要声明常函数

    void ShowPerson() const {

        //const Type* const pointer;

        //this = NULL; //this指针不能修改指针的指向 

        //this->mA = 100; //但是this指针指向的对象的数据是可以修改的

  

        //const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量

        this->m_B = 100;

    }

  

    void MyFunc() const {

        //mA = 10000;

    }

  

public:

    int m_A;

    mutable int m_B; //可修改 可变的

};

  
  

//const修饰对象  常对象

void test01() {

  

    const Person person; //常量对象  

    cout << person.m_A << endl;

    //person.mA = 100; //常对象不能修改成员变量的值,但是可以访问

    person.m_B = 100; //但是常对象可以修改mutable修饰成员变量

  

    //常对象访问成员函数

    person.MyFunc(); //常对象不能调用const的函数

  

}

  

int main() {

  

    test01();

  

    system("pause");

  

    return 0;

}