1、缘起

“成员变量和成员函数分开存储” 是面向对象编程中的一个重要概念。它指的是在类的实例化过程中，类的 成员变量 和 成员函数 分别存储在不同的内存位置。

2、详解

具体来说，当创建类的实例（对象）时，会为每个对象分配一块内存用于存储该对象的成员变量。这些成员变量是对象的属性，它们的值可以因对象而异。每个成员变量包含类定义中声明的实例变量，可以通过对象访问和操作。

而成员函数则被存储在类的代码区域，它们是类的行为或操作的定义。成员函数被所有该类的对象所共享，它们可以操作对象的成员变量，并对对象进行各种操作和处理。这种将成员变量和成员函数分开存储的方式有以下几个优点：

① 内存分配的效率：成员变量被存储在各个对象的内存中，每个对象只需存储自己的成员变量，避免了重复存储相同的成员变量，节省了内存空间。

② 对象的独立性：每个对象都有自己的成员变量，它们的值可以相互独立，互不影响。这样可以实现对象的封装和数据隔离，增强了对象的独立性和安全性。

③ 方法的共享性：所有对象共享类的成员函数，它们可以在不同的对象上执行相同的操作。这提供了代码的重用性和灵活性。

总的来说，将成员变量和成员函数分开存储有助于实现面向对象编程的封装、数据隔离和代码共享等特性，提高了程序的可维护性和可扩展性。

3、代码清单 1

3.1、类中定义成员变量

示例代码 1：定义一个空类

#include<iostream>
#include<string>

using namespace std;

class Person
{

};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}

从上述代码和结果图中可以看出，当定义一个空类时，C++ 编译器会给每个空对象也分配 1 个字节空间，是为了区分空对象占内存的位置，每个对象也应该有一个独一无二的内存地址。

示例代码 2：类中定义一个非静态成员变量

#include<iostream>
#include<string>

using namespace std;

class Person
{
	int p_age;
};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << " 字节" << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}

从上述代码和结果图中可以看出，当定义一个空类时，对象 p 占用 1 个字节的空间；当在这个空类中声明一个 非静态成员变量 （int p_age;）时，对象 p 占用 4 个字节的空间。这是因为非静态成员变量时属于类的对象上，并且被存储在各个对象的内存中，而对象 p 占用空间的大小就是 int 数据类型的大小。

示例代码 3：类中定义两个非静态成员变量

示例代码 2 的对照组。

#include<iostream>
#include<string>

using namespace std;

class Person
{
	int p_age;
	int p_height;
};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << " 字节" << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}

从上述代码和图片中可以看出，当在类中声明两个非静态成员变量时，对象 p 占用 8 个字节内存空间。

示例代码 4：类中定义一个静态成员变量

#include<iostream>
#include<string>

using namespace std;

class Person
{
	static int p_age;
};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << " 字节" << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}

从上述代码和结果图中可以看出，当在类中定义一个 静态成员变量 时，对象 p 占用 1 个内存空间，这和空类时对象 p 所占用的空间大小相等，这说明了静态成员变量不属于对象的成员，它是类的成员。

示例代码 5：类中定义两个静态成员变量

示例代码 4 的对照组。

#include<iostream>
#include<string>

using namespace std;

class Person
{
	static int p_age;
	static int p_height;
};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << " 字节" << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}

3.2、类中定义成员函数

示例代码 1：类中定义一个非静态函数

#include<iostream>
#include<string>

using namespace std;

class Person
{
	void func() {};
};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << " 字节" << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}

从上述代码和结果图中可以看出，当在类中定义一个 非静态成员变量 时，对象 p 占用 1 个内存空间，这和空类时对象 p 所占用的空间大小相等，这说明了非静态成员函数不属于对象的成员，它是类的成员。

示例代码 2：类中定义一个静态成员函数

#include<iostream>
#include<string>

using namespace std;

class Person
{
	static void func() {};
};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << " 字节" << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}

从上述代码和结果图中可以看出，当在类中定义一个 静态成员变量 时，对象 p 占用 1 个内存空间，这和空类时对象 p 所占用的空间大小相等，这说明了静态成员函数不属于对象的成员，它是类的成员。

4、代码清单 2

对代码清单 1 下列的代码进行简单汇总。

#include<iostream>
#include<string>

using namespace std;

class Person
{
	//非静态成员变量，属于类的对象上
	int p_age;

	//静态成员函数，不属于类的对象上
	static int p_height;

	//非静态成员函数，不属于类的对象上
	void func1() {};

	//静态成员变量，不属于类的对象上
	static void func2() {};
};

void test()
{
	Person p;

	cout << "对象 p 所占的内存空间大小：" << sizeof(p) << " 字节" << endl;
}

int main()
{
	test();

	cout << endl;
	system("pause");
	return 0;
}