C++对象模型
首先来说一说class的本质：
- class是一种特殊的struct
- 在内存中class依旧可以看作变量的集合
- class与struct遵循相同的内存对齐规则
- class中的成员函数与成员变量是分开存放的
- 每个对象有独立的成员变量
- 所有对象共享类中的成员函数
然后再来看一个问题：
class A
{
int i;
int j;
char c;
double d;
};
struct B
{
int i;
int j;
char c;
double d;
};
有上述1个类A、一个结构体B，请问执行下列语句输出多少？
sizeof(A) = ?
sizeof(B) = ?
最终输出结果为：
sizeof(A) = 24
sizeof(B) = 24
再举一个例子：
#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 i;
int j;
char c;
double d;
};
int main()
{
A a;
cout << "sizeof(A) = " << sizeof(A) << endl; // 20 bytes
cout << "sizeof(a) = " << sizeof(a) << endl;
cout << "sizeof(B) = " << sizeof(B) << endl; // 20 bytes
a.print();
//用B指针类型指向类A的对象
B* p = reinterpret_cast<B*>(&a);
//通过指针修改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;
}
最终输出结果为：
sizeof(A) = 24
sizeof(a) = 24
sizeof(B) = 24
i = 0, j = 1, c = , d = 2.26503e-314
i = 1, j = 2, c = c, d = 3
i = 100, j = 200, c = C, d = 3.14
从输出结果结合代码可以看出：
1、 类A 结构体B 内存大小是一样的
2、在定义类A的对象后，未初始化时，输出成员变量都是未初始化的值
3、使用结构体B的指针指向类A对象时，可以直接修改成员变量的值
分析得出：
- 运行时的类对象退化为结构体的形式
- 所有成员变量在内存中依次排布
- 成员变量间可能存在内存空隙
- 可以通过内存地址直接访问成员变量
- 访问权限关键字在运行时失效
- 类中的成员函数位于代码段中
- 调用成员函数时对象地址作为参数隐式传递
- 成员函数通过对象地址访问成员变量
- C++语法规则隐藏了对象地址的传递过程
继承对象模型
- 在C++编译器的内部 类可以理解为结构体
- 子类是由父类成员叠加子类新成员得到的
class Derived : public Demo
{
int mk;
};
Demo => int mi; <= Derived
Demo => int mj; <= Derived
int mk; <= Derived
首先来看一个例子：
#include <iostream>
#include <string>
using namespace std;
//类Demo
class Demo
{
//子类可以直接访问
protected:
int mi;
int mj;
public:
//虚函数print
virtual void print()
{
cout << "mi = " << mi << ", "
<< "mj = " << mj << endl;
}
};
//类Derived 继承Demo
class Derived : public Demo
{
//子类中的成员变量mk
int mk;
public:
//带参构造函数
Derived(int i, int j, int k)
{
mi = i;
mj = j;
mk = k;
}
//子类成员函数print
void print()
{
cout << "mi = " << mi << ", "
<< "mj = " << mj << ", "
<< "mk = " << mk << endl;
}
};
//结构体Test
struct Test
{
//包含1个指针 3个int类型变量
//这个指针是指向虚函数表的指针
//虚函数表指针位于对象最开始的位置
void* p;
int mi;
int mj;
int mk;
};
int main()
{
//输出Demo类和Derived类
cout << "sizeof(Demo) = " << sizeof(Demo) << endl;
cout << "sizeof(Derived) = " << sizeof(Derived) << endl;
//定义并初始化d
Derived d(1, 2, 3);
//使用结构体Test指针指向Derived类对象
Test* p = reinterpret_cast<Test*>(&d);
cout << "Before changing ..." << endl;
//输出成员变量以及父类的成员变量
d.print();
//直接通过p指针来赋值d的成员变量
p->mi = 10;
p->mj = 20;
p->mk = 30;
cout << "After changing ..." << endl;
//输出各成员变量
d.print();
return 0;
}
输出结果如下：
sizeof(Demo) = 16
sizeof(Derived) = 24
Before changing ...
mi = 1, mj = 2, mk = 3
After changing ...
mi = 10, mj = 20, mk = 30
在这里说明一下，由于是在64位系统下运行，所以指针占8个字节。Demo占16个字节，是包含了2个4字节的int变量，加上1个8字节指向虚函数表的指针，共16个字节。Derived占24个字节是因为内存对齐，直接给int类型的mk变量分配8个字节，所以共24个字节。使用Test结构体指向Derived类对象时，要注意指向虚函数表的指针是位于对象内存最开始的位置，void * p就是这个指针，其余的按顺序排列。
- C++多态的实现原理
- 当类中声明虚函数时，编译器会在类中生成一个虚函数表
- 虚函数表是一个存储成员函数地址的数据结构
- 虚函数表是由编译器自动生成与维护的
- virtual成员函数会被编译器放入虚函数表中
- 存在虚函数时，每个对象中都有一个指向虚函数表的指针
当有Demo类如下：
class Demo
{
int mi, mj;
public:
virtual int add(int value)
{
return mi + mj + value;
}
};
此时这个对象就会有一个指针，指向编译器维护的虚函数表。虚函数表中保存这成员函数的地址：
VTABLE => void Demo :: add(int value)
当有Derived类继承Demo类时，如下：
class Derived : public Demo
{
int mk;
public:
virtual int add(int value)
{
return mk + value;
}
};
此时这个对象也会有一个指针，指向编译器维护的虚函数表。虚函数表中保存这成员函数的地址：
VTABLE => void Derived :: add (int value)
当执行这个函数时：
void run(Demo * p, int v)
{
p -> add(v);
}
执行时，编译器会确认 add( ) 是否为虚函数？
1、Yes -> 编译器在对象 VPTR 所指向的虚函数表中查找 add ( ) 的地址
2、No -> 编译器直接可以确定被调成员函数的地址
所以，调用顺序如下：
p -> VPTR -> VTABLE void (*pAdd)(int value) -> 0xFF010203
调用效率对比： 虚函数 < 普通成员函数
