1 class A                      struct B
2 {                            {
3     int i;                        int i;
4     int j;                        int j;
5     char c;                       char c;
6     double d;                     double d;
7 };                           };
8
9 sizeof(A) = ?                sizeof(B) = ?

 1 #include <iostream>
 2 #include <string>
 3
 4 using namespace std;
 5
 6 class A
 7 {
 8     int i;
 9     int j;
10     char c;
11     double d;
12 public:
13     void print()  // 虽然写在一起，但是在内存中的排布是在不同的地方的；
14     {
15         cout << "i = " << i << ", "
16              << "j = " << j << ", "
17              << "c = " << c << ", "
18              << "d = " << d << endl;
19     }
20 };
21
22 struct B
23 {
24     int i;
25     int j;
26     char c;  // 虽然 char 类型大小为 1 个字节，但是由于内存对齐，其大小为 4 个字节，其中三个字节是内存空隙；
27     double d;
28 };
29
30 int main()
31 {
32     A a;
33
34     cout << "sizeof(A) = " << sizeof(A) << endl;  // 20 bytes，数据类型本质就是固定内存空间大小的别名；
35     cout << "sizeof(a) = " << sizeof(a) << endl;  // 20 bytes，C++ 对象中并没有包含成员函数，其仅仅代表成员变量的集合；
36     cout << "sizeof(B) = " << sizeof(B) << endl;  // 20 bytes
37
38     a.print();  // 打印乱码
39
40     B* p = reinterpret_cast<B*>(&a);  // 用 reinterpret_cast 重解释 a 对象所代表的这一段内存；
41
42     /* 将 a 对象当做一个结构体 B 的变量来使用；由于 a 里面的成员变量在内存空间里面的排布与 struct B 在内存空间里面的排布是一样的，所有就可以通过下列方式就可以修改 a 对象里面的私有成员 */
43     p->i = 1;
44     p->j = 2;
45     p->c = 'c';
46     p->d = 3;
47
48     a.print();  // 打印 i = 1, j = 2, c = c, d = 3；这里结果说明一个对象真的就是一个结构体；可以将一个对象当做一个结构体来使用；
49
50     p->i = 100;
51     p->j = 200;
52     p->c = 'C';
53     p->d = 3.14;
54
55     a.print();  // 打印 i = 100, j = 200, c = C, d = 3.14，不是巧合
56
57     return 0;
58 }

 1 #include <iostream>
 2 #include <string>
 3
 4 using namespace std;
 5
 6 class Demo
 7 {
 8     int mi;
 9     int mj;
10 public:
11     Demo(int i, int j)
12     {
13         mi = i;
14         mj = j;
15     }
16
17     int getI()
18     {
19         return mi;
20     }
21
22     int getJ()
23     {
24         return mj;
25     }
26
27     int add(int value)
28     {
29         return mi + mj + value;
30     }
31 };
32
33 int main()
34 {
35     Demo d(1, 2);
36
37     cout << "sizeof(d) = " << sizeof(d) << endl;  // 8 bites；
38     cout << "d.getI() = " << d.getI() << endl;  // 1；
39     cout << "d.getJ() = " << d.getJ() << endl;  // 2；
40     cout << "d.add(3) = " << d.add(3) << endl;  // 6；
41
42     return 0;
43 }

 1 #ifndef _50_2_H_
 2 #define _50_2_H_
 3
 4 typedef void Demo;  // 定义一个新的类型（作为类类型，这里能看到的也只有这个类型）；
 5
 6 Demo* Demo_Create(int i, int j);  // 作为构造函数看待；C++ 中之所以没有返回值，是因为已经存在了；
 7 int Demo_GetI(Demo* pThis);  // 地址的传递过程，用 pThis 实现；
 8 int Demo_GetJ(Demo* pThis);
 9 int Demo_Add(Demo* pThis, int value);
10 void Demo_Free(Demo* pThis);  // C 中编译器不可能提供析构函数，要自己定义；C++ 中之所以没有返回值，是因为已经存在了；
11
12 #endif

 1 #include "50-2.h"
 2 #include "malloc.h"
 3
 4 /* 结构体代表真正的类，反映了 class 这个类的本质就是结构体 */
 5 struct ClassDemo
 6 {
 7     int mi;
 8     int mj;
 9 };
10
11 /* 实现构造函数 */
12 /* 其实我们实实在在的定义了这个结构体，但是对于用户而言，根本没有必要知道这个类是如何实现的，对于一个类的用户而言，只用知道如何使用成员函数就可以了 */
13 Demo* Demo_Create(int i, int j)  // 构造函数没有 this 指针；
14 {
15     struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo));  // C 中需要加 struct；
16
17     if( ret != NULL )
18     {
19         ret->mi = i;
20         ret->mj = j;
21     }
22
23     return ret;
24 }
25
26 int Demo_GetI(Demo* pThis)  // pThis 代表当前对象
27 {
28      struct ClassDemo* obj = (struct ClassDemo*)pThis;
29
30      return obj->mi;
31 }
32
33 int Demo_GetJ(Demo* pThis)
34 {
35     struct ClassDemo* obj = (struct ClassDemo*)pThis;
36
37     return obj->mj;
38 }
39
40 int Demo_Add(Demo* pThis, int value)
41 {
42     struct ClassDemo* obj = (struct ClassDemo*)pThis;
43
44     return obj->mi + obj->mj + value;
45 }
46
47 void Demo_Free(Demo* pThis)
48 {
49     free(pThis);
50 }

 1 #include <stdio.h>
 2 #include "50-2.h"
 3
 4 int main()
 5 {
 6     Demo* d = Demo_Create(1, 2);  // d 代表一个指针，指向一个对象；等价的 C++ 中的代码为 Demo* d = new Demo(1, 2);
 7
 8     printf("d.mi = %d\n", Demo_GetI(d));     // d->getI();
 9     printf("d.mj = %d\n", Demo_GetJ(d));     // d->getJ();
10     printf("Add(3) = %d\n", Demo_Add(d, 3));    // d->add(3);
11
12     // d->mi = 100;  // 1，warning: dereferencing 'void *' pointer （正在间接引用空指针）；error: request for member 'mi' in something not a structure or union （在非结构体和联合体中访问成员 mi) ；
13                      // 2，面向对象的观点来看，mi 是私有的，类的外部不可以访问，只能通过成员函数访问，这是面向对象中的信息隐藏；
14                      // 3，在 C 语言中，没有 private 关键字，因此我们只能用 typedef void Demo 这样的技术，通过定义一个 void 的 Demo 来进行信息隐藏，进行 private 的模拟；
15
16     Demo_Free(d);
17
18     return 0;
19 }