一、回归本质

• class 是一种特殊的 struct
  • 在内存中 class 依旧可以看作变量的集合
  • class 与 struct 遵循相同的内存对齐规则
  • class 中的成员函数与成员变量是分开存放的
    • 每个对象有独立的成员变量
    • 所有对象共享类中的成员函数
• 值得思考的问题

        下面看一个对象内存布局的代码：

#include <iostream>

using namespace std;

class A
{
    int i;
    int j;
    char c;
    double d;
public:
    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;  //20 byte
    cout << "sizeof(a) = " << sizeof(a) <<  endl;
    cout << "sizeof(B) = " << sizeof(B) <<  endl;
    
    a.print();
    
    B* p = reinterpret_cast<B*>(&a);
    
    p->i = 1;
    p->j = 2;
    p->c = 'c';
    p->d = 3;
    
    a.print();
    
    p->i = 100;
    p->j = 200;
    p->c = 'C';
    p->d = 3.14;
    
    a.print();
    
    return 0;
}

        输出结果如下：

1. 首先，学习采用的为 ubuntu 10.10，其 gcc 编译器暂时不支持 8 字节对齐，默认按照 4 字节对齐，所以 A 和 B 中的 d 的对齐参数为 4，故 A 和 B 占用内存大小为 20 字节（详情看：【C语言进阶剖析】24.C语言中的 #pragma 使用分析）
2. 成员变量可能排布在栈空间、可能排布在堆空间，还有可能排布在全局数据区，而成员函数只可能存在于代码段
3. 为什么要用 reinterpret_cast 这个关键词，这是因为我们需要解释 a 这个对象代表的内存，关于 C++ 强制类型转换，可以看：【C++基础入门】9.C++中的类型转换
4. 通过后面两个例子说明一个对象是一个特殊的结构体，由于 a 对象成员变量与 B 结构体中的变量在内存中的排布相同，因此，可以利用指针修改 a 这个对象中的私有成员

二、C++对象模型分析

• 运行时的对象退化为结构体的形式
  • 所有成员变量在内存中依次排布
  • 成员变量间可能存在内存空隙
  • 可以通过内存地址直接访问成员变量
  • 访问权限关键字在运行时失效
• 类中的成员函数位于代码段中
• 调用成员函数时对象地址作为参数隐式传递
• 成员函数通过对象地址访问成员变量
• C++ 语法规则隐藏了对象地址的传递过程

        下面进行对象本质分析：

#include <iostream>
#include <string>

using namespace std;

class Demo
{
    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;
}

        输出结果如下：

        d 对象的地址被传到了 getI() 这个函数的内部，但是这个传递过程在 C++ 的代码中是看不到的，下面我们用 C 语言模拟实现这个过程，挖掘编译器背后的故事 

        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 = %d\n", Demo_GetI(d));     // d->getI();
    printf("d.mj = %d\n", Demo_GetJ(d));     // d->getJ();
    printf("Add(3) = %d\n", Demo_Add(d, 3));    // d->add(3);
    
    // d->mi = 100;
    
    Demo_Free(d);
    
    return 0;
}

        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);
void Demo_Free(Demo* pThis);

#endif

         demo.c

#include "demo.h"
#include "malloc.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;
}

void Demo_Free(Demo* pThis)
{
    free(pThis);
}

         输出结果如下：

1. 由于Demo是 void 类型，所以 pThis 需要强制类型转化为 struct ClassDemo 类型
2. main.c 中，d 是指针，指向的就是模拟对象的地址
3. 运行 d->mi = 100; 会报如下错误，从面向对象的观点来看，mi 是私有的，在类的外部是不能访问的，只能通过成员函数进行访问，这是面向对象中的信息隐藏，由于 C语言中没有 private 关键字，所以只能通过 void 进行信息隐藏，从而模拟 private 关键字

 

三、小结

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