50、C++对象模型分析（上）

1、回归本质

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

#include <iostream>
#include <string>
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 m;
	int n;
	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;
	a.print();

	B* b = reinterpret_cast<B*>(&a);

	b->m = 1;
	b->n = 1;
	b->c = 'c';
	b->d = 100;

	a.print();
	
	return 0;
}

很明显两个所占用的内存空间都是一样的，在gcc编译器下占的字节数为24字节，不过问题不大，VS是以8字节为标准。并且类 A 和 结构体 B 的内存布局都是一样的。

C++对象并没有包括成员函数，一个C++对象仅仅代表成员变量的集合，并不会因为加了成员函数而内存变大。成员变量可能存放在栈，堆，和全局数据区。而成员函数存放在代码段。

对于指针类型的强制类型转换，我们用 reinterpret_cast 去转换。这样，当我们用结构体指针 b 指向一个对象 a 时，当结构体里面的值发生改变时，由于类 A 和 结构体 B 的内存布局都是一样的，两个之间的成员变量就会发生一样的变化。如果类 A 和 结构体 B 的内存布局不一样，那么类里面的值就会有很大的出入。还有一点我们可以发现，类里面的成员变量都是 private 的权限，外界不能访问和修改，通过这样的操作竟然进行了修改，牛批。

2、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;
}

用C语言来表达C++：

50-2.h

#ifndef _50_2_H_
#define _50_2_H_
#pragma once
typedef void Demo;

Demo* Demo_creat(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

50-2.c

#include "50-2.h"
#include <malloc.h>
struct ClassDemo
{
	int mi;
	int mj;
};
Demo* Demo_creat(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* ret = (struct ClassDemo*)pThis;
	return ret->mi;
}
int Demo_getJ(Demo* pThis)
{
	struct ClassDemo* ret = (struct ClassDemo*)pThis;
	return ret->mj;
}
int Demo_Add(Demo* pThis, int value)
{
	struct ClassDemo* ret = (struct ClassDemo*)pThis;
	return ret->mi + ret->mj + value;;

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

main.c

#include <stdio.h>
#include "50-2.h"

int main()
{
	Demo* d = Demo_creat(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("d.add(3) = %d\n", Demo_Add(d, 3));		//等同于 d->add(3)

	Demo_Free(d);

	return 0;
}

我们用C语言还原了C++语法规则隐藏了对象地址的传递过程，调用成员函数时对象地址作为参数隐式传递，成员函数通过对象地址访问成员变量。用结构体来代替类，通过结构体指针来指向堆上的结构体，从而指向结构体中的数。也就相当于C++中通过对象指向成员函数得出成员变量的值。通过Demo这个void 的类型体现封装性，妙啊。

小结：

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