在C++中，成员变量和成员函数是分开存储的，只有非静态成员变量才存储在类中或类的对象上。通过该类创建的所有对象都共享同一个函数

#include <iostream>
using namespace std;

class Monster
{
    public:
    //成员函数不占对象空间，所有对象共享同一个函数
    Monster():m_monsterId(0)
    {

    }
    //成员函数不占对象空间，所有对象共享同一个函数
    Monster(const int monsterId):m_monsterId(monsterId)
    {

    }
    //成员函数不占对象空间，所有对象共享同一个函数
    Monster(const Monster &m)
    {
        m_monsterId = m.m_monsterId;
    }
    //成员函数不占对象空间，所有对象共享同一个函数
    ~Monster()
    {

    }

    //静态成员函数存储在全局静态区，不占对象空间
    static void setMonsterCounter(const int counter)
    {
        ms_counter = counter;
    }

    //静态成员函数存储在全局静态区，不占对象空间
    static int getMonsterCounter()
    {
        return ms_counter;
    }

    private:
    //静态成员变量存储在全局静态区，不占对象空间
    static int ms_counter; //计数

    //非静态成员变量，占对象空间
    int m_monsterId; //怪物id
};

int Monster::ms_counter = 0;

int main(int argc, char *argv[])
{
    cout << "sizeof(Monster) = " << sizeof(Monster) << endl;
    Monster m;
    cout << "sizeof(m) = " << sizeof(m) << endl;

    return 0;
}

在C++中，空类占用内存大小为一个字节，因为即使是一个空对象，也要分配存储空间来识别这个空对象，所以C++分配了一个字节大小的空间给每一个空对象。

#include <iostream>
using namespace std;

class Monster
{

};

int main(int argc, char *argv[])
{
    Monster m;

    cout << "空类占用内存大小为：" << sizeof(Monster) << endl;
    cout << "空对象占用内存大小为：" << sizeof(m) << endl;

    return 0;
}

C++中成员变量和成员函数是分开存储的，只有非静态成员才存储在类中或类的对象上。不管通过该类创建了多少对象，该类的每一个非静态成员函数只有一份，所有对象都同享非静态成员函数，那么这些非静态成员函数是如何区分是哪个对象调用自己的呢？C++通过this指针，解决这个问题。

this指针的特点：

1. this指针隐含在每一个非静态成员函数内，每一个非静态成员函数都隐含有一个this指针。当对象调用非静态成员函数时，this指针指向该对象。

2. this指针是是在非静态成员函数的开始前构造，并在非静态成员函数的结束后清除的，不需要声明，直接使用即可。

3. this指针的本质是指针常量，存储了调用该非静态成员函数的对象的地址，所以this指针的指向是不可以修改的。

注意：这里我们一直强调：每一个非静态成员函数都隐含有一个this指针，而静态成员函数的函数体内只能访问静态成员变量和静态成员函数，不能访问非静态成员变量和非静态成员函数，所以静态成员函数是没有this指针的。

this指针的作用：

1. 在类的非静态成员函数中，形参和成员变量同名时，可以通过this指针来指明是对象的成员，还是形参名。

2. 在类的非静态成员函数中需要返回该对象时，通过使用：return *this; 返回该对象自身。

#include <iostream>
using namespace std;

class Monster
{
    public:
    Monster():monsterId(0)
    {

    }
    
    //这里通过对象初始化列表的方式，是可以区分:monsterId是成员变量，(monsterId)是形参的
    //而且对象初始化列表中不能用:this->monsterId(monsterId)
    Monster(const int monsterId):monsterId(monsterId)
    {

    }
    Monster(const Monster &m):monsterId(m.monsterId)
    {

    }

    ~Monster()
    {

    }

    Monster& getSelf()
    {
        return *this; //返回对象本身
    }

    // static Monster& getSelfByStatic()
    // {
    //     return *this; //错误：非静态成员函数没有this指针
    // }

    void setMonsterId(const int monsterId)
    {
        this->monsterId = monsterId; //形参和成员变量同名，所以需要用this指针区分，不然编译器不知道monsterId是成员变量还是形参
    }

    int getMonsterId()
    {
        return monsterId;
    }

    private:
    int monsterId;
};

int main(int argc, char *argv[])
{
    Monster m(10001);
    cout << "怪物id = " << m.getMonsterId() << endl;
    m.setMonsterId(10002);
    cout << "怪物id = " << m.getSelf().getMonsterId() << endl;

    return 0;
}

注意：通过对象初始化列表的方式，是可以区分:monsterId是成员变量，(monsterId)是形参的，而且对象初始化列表中不能用:this->monsterId(monsterId)，编译器会报错的

//这里通过对象初始化列表的方式，是可以区分:monsterId是成员变量，(monsterId)是形参的
//而且对象初始化列表中不能用:this->monsterId(monsterId)，编译器会报错的
Monster(const int monsterId):monsterId(monsterId)
{

}

C++中是允许空指针调用成员函数的，这时this = NULL；所以在非静态成员函数中，如果用到this指针，应该在用到this指针前，加以判断this指针是否为NULL。但是在程序设计的过程中，我们应该尽量禁用用空指针调用成员函数，稍微不注意，可能会导致我们的程序出现崩掉的情况。

const修饰的类成员

1. 常量成员变量：在成员变量前，用const修饰该的成员变量（eg：const int m_monsterId;）。常量成员变量只能在构造函数中用初始化列表进行初始化，并且初始化后不能再修改。

2. 常量成员函数：在成员函数后加上const修饰的成员函数（eg：void getMonsterId() const），也叫常函数。常量成员函数不能修改普通的成员属性，但常量成员函数可以对有mutable修饰的成员属性进行修改。

常对象

const修饰的对象叫常对象，常对象只能调用常函数

#include <iostream>
using namespace std;

class Monster
{
    public:
    Monster():m_monsterId(0), m_name("怪物"), m_blood(500)
    {

    }
    Monster(const int monsterId, const string name, const int blood):m_monsterId(monsterId), 
                                                                     m_name(name), m_blood(blood)
    {

    }
    Monster(const Monster &m):m_monsterId(m.m_monsterId), m_name(m.m_name), m_blood(m.m_blood)
    {
        //m_name = m.m_name; //错误：常量成员属性只能用初始化列表进行初始化，这句调用编译器会报错
    }
    ~Monster()
    {

    }

    void setMonsterId(const int monsterId)
    {
        m_monsterId = monsterId;
    }
    int getMonsterId() const
    {
        //m_monsterId = 0; //错误：常函数不能修改普通成员变量的值
        return m_monsterId;
    }

    void setName(const string name)
    {
        //m_name = name; //错误：m_name是常量成员属性，不能修改
    }
    string getName() const
    {
        return m_name;
    }

    void setBlood(const int blood) const
    {
        m_blood = blood; //正确：常函数可以修改用mutable修饰的成员属性
    }
    int getBlood()
    {
        return m_blood;
    }

    int getCounter()
    {
        return ms_counter;
    }

    private:
    int m_monsterId; //怪物id
    const string m_name; //怪物名字  常量成员属性
    mutable int m_blood; //血量

    static int ms_counter;
};
int Monster::ms_counter = 0;

int main(int argc, char *argv[])
{
    Monster m1(10001, "雪女", 10000);
    cout << "怪物id = " << m1.getMonsterId() << "，怪物名字 = " << m1.getName() << "，怪物血量 = " << m1.getBlood() << endl;

    const Monster m2(20001, "紫衣仙子", 20000);
    cout << "怪物id = " << m2.getMonsterId() << endl; //正确：常对象可以调用常函数
    //m2.setMonsterId(20002); //错误：常对象不可以调用普通成员函数
    //m2.getCounter(); //错误：常对象不可以调用静态成员函数
    return 0;
}

类的静态(static)成员和常量(const)成员是两个不同的概念，我们不应该混淆

类的静态成员

1. static成员变量

1. 所有对象共享一份数据

2. 在编译阶段分配内存

3. 类内声明，类外初始化

4. 有（public，protected，private）访问权限

2. static成员函数（在成员函数前加 static）

1. 所有对象共享一个函数

2. 静态成员函数的函数体内只能访问静态成员变量或静态成员函数，不能访问非静态成员变量和非静态成员函数

3. 有（public，protected，private）权限