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

#include 
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 
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 
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 
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; //怪物idconst 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）权限