成员变量和成员函数分开存储（1）

C++中类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上的数据

空对象占用的内存空间为：1

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 //成员变量 和 成员函数 分开存储的
 6 class Person
 7 {
 8 
 9 };
10 
11 
12 void test_01(void)
13 {
14     Person p;
15     //空对象占用内存空间为：
16     cout << "size of p:" << sizeof(p) << endl;
17 }
18 
19 int main(void)
20 {
21     test_01();
22 
23     system("pause");
24     return 0;
25 }

 

 

 只有非静态成员变量才属于类的对象上的数据：

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 //成员变量 和 成员函数 分开存储的
 6 class Person
 7 {
 8     int m_A;//非静态成员变量 属于类的对象上的数据
 9 
10 };
11 
12 
13 void test_01(void)
14 {
15     Person p;
16     //空对象占用内存空间为：1    为什么？
17     //因为C++编译器会给每个空对象也分配 1 个字节空间，是为了区分空对象所占内存的位置
18     //每个空对象也因该有一个独一无二的内存地址
19     cout << "size of p:" << sizeof(p) << endl;
20 }
21 
22 void test_02(void)
23 {
24     Person p;
25     cout << "size of p:" << sizeof(p) << endl;
26 }
27 
28 
29 int main(void)
30 {
31     //test_01();
32     test_02();
33 
34     system("pause");
35     return 0;
36 }

 

 

sizeof(p)!=5，sizeof(p)!=8。

sizeof(p) =4。

从侧面证明了：非静态成员变量，是属于类上面的数据。

静态成员变量它不属于类的对象上面的数据：

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 //成员变量 和 成员函数 分开存储的
 6 class Person
 7 {
 8     int m_A;//非静态成员变量 属于类的对象上的数据
 9     static int m_B;//静态成员变量类内定义 
10 
11 };
12 
13 int Person:: m_B = 0;//静态成员变量类外初始化
14 
15 void test_01(void)
16 {
17     Person p;
18     //空对象占用内存空间为：1    为什么？
19     //因为C++编译器会给每个空对象也分配 1 个字节空间，是为了区分空对象所占内存的位置
20     //每个空对象也因该有一个独一无二的内存地址
21     cout << "size of p:" << sizeof(p) << endl;
22 }
23 
24 void test_02(void)
25 {
26     Person p;
27     cout << "size of p:" << sizeof(p) << endl;
28 }
29 
30 
31 int main(void)
32 {
33     //test_01();
34     test_02();
35 
36     system("pause");
37     return 0;
38 }

 

 

 结论：静态成员变量不占类的对象上的内存空间，所以它不属于类的对象上的数据。

非静态成员函数：

成员变量 和 成员函数是分开存储的

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 //成员变量 和 成员函数 分开存储的
 6 class Person
 7 {
 8     int m_A;//非静态成员变量 属于类的对象上的数据
 9     static int m_B;//静态成员变量类内定义 
10 
11     void func(void)//非静态成员函数
12     {
13 
14     }
15 
16 };
17 
18 int Person:: m_B = 0;//静态成员变量类外初始化
19 
20 void test_01(void)
21 {
22     Person p;
23     //空对象占用内存空间为：1    为什么？
24     //因为C++编译器会给每个空对象也分配 1 个字节空间，是为了区分空对象所占内存的位置
25     //每个空对象也因该有一个独一无二的内存地址
26     cout << "size of p:" << sizeof(p) << endl;
27 }
28 
29 void test_02(void)
30 {
31     Person p;
32     cout << "size of p:" << sizeof(p) << endl;
33 }
34 
35 
36 int main(void)
37 {
38     //test_01();
39     test_02();
40 
41     system("pause");
42     return 0;
43 }

 

 

 结论：非静态成员函数也不占用对象的内存空间，它在类里只有独一无二的一份就可以了！

静态成员函数：

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 //成员变量 和 成员函数 分开存储的
 6 class Person
 7 {
 8     int m_A;//非静态成员变量 属于类的对象上的数据
 9     static int m_B;//静态成员变量类内定义 不属于类的对象上的数据
10 
11     void func1(void)//非静态成员函数 不属于类的对象上的数据
12     {
13 
14     }
15 
16     static void func2(void)//静态成员函数 不属于类的对象上的数据
17     {
18 
19     }
20 
21 };
22 
23 int Person:: m_B = 0;//静态成员变量类外初始化
24 
25 void test_01(void)
26 {
27     Person p;
28     //空对象占用内存空间为：1    为什么？
29     //因为C++编译器会给每个空对象也分配 1 个字节空间，是为了区分空对象所占内存的位置
30     //每个空对象也因该有一个独一无二的内存地址
31     cout << "size of p:" << sizeof(p) << endl;
32 }
33 
34 void test_02(void)
35 {
36     Person p;
37     cout << "size of p:" << sizeof(p) << endl;
38 }
39 
40 
41 int main(void)
42 {
43     //test_01();
44     test_02();
45 
46     system("pause");
47     return 0;
48 }

总结：无论是静态成员变量、静态成员函数、非静态成员函数 都不属于类对象上的数据。是共享的独一无二的一份！

只有非静态成员变量属于类对象上的数据！

 

posted @ 2020-04-14 14:56  坦率  阅读(363)  评论(1)  编辑  收藏  举报