【C++】成员对象和成员函数分开存储

Aperion

已于 2023-06-04 11:04:59 修改

阅读量679

点赞数 1

分类专栏： C++ 文章标签： c++

于 2023-06-04 11:00:56 首次发布

本文链接：https://blog.youkuaiyun.com/qq_51870334/article/details/130902149

版权

C++ 专栏收录该内容

28 篇文章

订阅专栏

文章详细解释了成员变量和成员函数在面向对象编程中的存储方式，强调了它们在不同内存位置的概念。成员变量存储于每个对象的内存中，而成员函数存储在类的代码区域，共享给所有对象。这种设计优化了内存使用，实现了对象的独立性和代码重用。代码示例展示了不同类型的成员变量和函数如何影响对象的内存占用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

欢迎来到博主 Apeiron 的博客，祝您旅程愉快！时止则止，时行则行。动静不失其时，其道光明。

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;
}