C++类的存储方式_c++ 类的存储方式

1.初始化列表

C++提供了初始化列表语法，用来初始化类的属性
语法：构造函数()：属性1(值1),属性2（值2）... {}
示例：

class Person {
public:

	传统方式初始化
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

int main() {

	Person p(1, 2, 3);
	p.PrintPerson();


	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2.类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员。

2.1特点

1.当类中成员是其他类对象时，我们称该成员为对象成员
2.构造的顺序是 ：先调用对象成员的构造，再调用本类构造
3.析构的顺序是：先调用本类的析构，再调用对象成员的析构

2.2示例

例如：

 class A {}
 class B
 {  A a；}
1
2
3

B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？
示例：

class Phone
{
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}

	~Phone()
	{
		cout << "Phone析构" << endl;
	}

	string m_PhoneName;

};


class Person
{
public:

	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person构造" << endl;
	}

	~Person()
	{
		cout << "Person析构" << endl;
	}

	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	}

	string m_Name;
	Phone m_Phone;

};
void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
	//析构顺序与构造相反
	Person p("张三" , "苹果X");
	p.playGame();

}


int main() {

	test01();

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

3.类的存储方式

类的存储还是很好理解的
在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上

1.非静态成员函数肯定是所有对象共享的，不属于某一个特定的对象
2.静态成员变量存储在全局区（静态区），它在运行前编译器就已经为其开辟好存储空间，不可能于类的对象存储在一起。
3.静态成员函数存储在代码区，和非静态成员变量存储的内存段是一样的。
4.非静态成员变量存储在栈上，属于类的对象上。
总结：计算一个类的对象在内存中所占字节数，就是计算非静态成员变量总和在内存中所占字节数。（注意内存对齐规则）

如果对内存对齐规则不是很了解，可以参考：
结构体内存对齐

4.总结

虽然类中的成员在内存中的存储位置是不一样的，但把他们封装在一起，可以具体且详细地描述一个对象的属性和行为。