回归本质

• class 是一种特殊的 struct

  • 在内存中 class 依旧可以看作变量的集合
  • class 与 struct 遵循相同的内存对齐规则

  • class 中的成员函数与成员变量是分开存放的

    • 每个对象有独立的成员变量【栈空间、堆空间、全局数据区】
    • 所有对象共享类的成员函数【代码段】

• 值得思考的问题

void code_1()
{
    class A
    {
        int i;
        int j;
        char c;
        double d;
    };
    
    cout << "sizeof(A) : " << sizeof(A) << endl;   // ??
}

void code_2()
{
    struct B
    {
        int i;
        int j;
        char c;
        double d;
    };
    
    cout << "sizeof(B) : " << sizeof(B) << endl;   // ?? 
}

编程实验： 对象内存布局初探

#@H_360_138@include <iostream>

using namespace std;

class A
{
private:
    int i;
    int j;
    char c;
    double d;
public:
    A()
    {
        i = 0;
        j = 0;
        c = 0;
        d = 0;
    }

    void print()
    {
        cout << "i = " << i << ", "
             << "j = " << j << ", "
             << "c = " << c << ", "
             << "d = " << d << endl;
    }
};

struct B
{
    int i;
    int j;
    char c;
    double d;
};

int main()
{
    A a;
    
    cout << "sizeof(A) = " << sizeof(A) << endl;    // 注意这里！
    cout << "sizeof(a) = " << sizeof(a) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;
    
    B*p = reinterpret_cast<B*>(&a);                 // 注意这里！
    
    a.print();
    
    p->i = 1;                                       // 注意这里！
    p->j = 2;
    p->c = 'c';
    p->d = 3;
    
    a.print();

    return 0;
}

输出：
sizeof(A) = 20
sizeof(a) = 20
sizeof(B) = 20
i = 0, j = 0, c = , d = 0
i = 1, j = 2, c = c, d = 3

结论：
1. 对象是一个特殊的结构体；
2. 通过内存操作可以访问类中的私有成员变量

C++ 对象模型分析

• 运行时的对象退化为结构体的形式

  • 所有成员变量在内存中依次排布
  • 成员变量间可能存在内存空隙
  • 可以通过内存地址直接访问成员变量
  • 访问权限关键字只在编译时有效在运行时无效

• 类中的成员函数位于代码段中
• 调用成员函数时对象地址作为参数隐式传递
• 成员函数通过对象地址访问成员变量
• C++ 语法规则隐藏了对象地址的传递过程

编程实验： 对象本质分析

#include <iostream>

using namespace std;

class Demo
{
private:
    int mi;
    int mj;
public:
    Demo(int i, int j)
    {
        mi = i;
        mj = j;
    }
    
    int getI()
    {
        return mi;
    }
    
    int getJ()
    {
        return mj;
    }
    
    int add(int value)
    {
        return mi + mj + value;
    }
};

int main()
{
    Demo d(1, 2);
    
    cout << "sizeof(d) = " << sizeof(d) << endl;
    cout << "d.getI() = " << d.getI() << endl;
    cout << "d.getJ() = " << d.getJ() << endl;
    cout << "d.add(3) = " << d.add(3) << endl;

    return 0;
}

输出：
sizeof(d) = 8
d.getI() = 1
d.getJ() = 2
d.add(3) = 6

编程实验： 对象本质分析

C 语言中类的模拟实现
Demo.h

#ifndef _DEMO_H_
#define _DEMO_H_

typedef void Demo;

Demo* Demo_Create(int i,int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_Add(Demo* pThis, int value);
int Demo_Free(Demo* pThis);

#endif

Demo.c

#include <;malloc.h>
#include "Demo.h"

struct ClassDemo
{
    int mi;
    int mj;
};

Demo* Demo_Create(int i,int j)
{
    struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo));
    
    if( ret != NULL )
    {
        ret->mi = i;
        ret->mj = j;
    }
    
    return ret;
}

int Demo_GetI(Demo* pThis)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;
    
    return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;
    
    return obj->mj;
}

int Demo_Add(Demo* pThis, int value)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;
    
    return (obj->mi + obj->mj + value);
}
int Demo_Free(Demo* pThis)
{
    free(pThis);
}

main.c

#include <stdio.h>
#include "Demo.h"

int main()
{
    Demo* d = Demo_Create(1, 2);              // Demo* d = new Demo(1, 2);
    
    printf("d.mi = %dn", Demo_GetI(d));      // d->getI();
    printf("d.mj = %dn", Demo_GetJ(d));      // d->getJ();
    printf("Add(3) = %dn", Demo_Add(d, 3));  // d->add(3);
    
    Demo_Free(d);
    
    return 0;
}

输出：
d.mi = 1
d.mj = 2
Add(3) = 6

结论：
在 C 语言中，仍然可以使用面向对象的方式编程；

小技巧： C 语言中的信息隐藏

typedef void Demo; 重命名 void 类型，使得外部无法通过相应的变量名直接访问结构体中成员(C++ private)

int main()
{
    Demo* d = Demo_Create(1, 2); 

    d->mi;                  // 注意这里！
}

main.c: In function ‘main’:
main.c:14: warning: dereferencing ‘void *’ pointer
main.c:14: error: request for member ‘mi’ in something not a structure or union

小结

• C++ 中的类对象在内存布局上与结构体相同
• 成员变量和成员函数在内存中分开存放
• 访问权限关键字在运行时无效
• 调用成员函数时对象地址作为参数隐式传递

以上内容参考狄泰软件学院系列课程，请大家保护原创！