C++对象模型
实例化对象
影响因素
虚函数 由虚表指针指向,所有对象共享。 非虚函数 所有对象共享。 非静态数据成员 对象大小的决定因素 静态函数 所有对象共享。 静态数据成员
内存对齐 可以手动指定。32位、64位不同。
class Abstract {
public:
Abstract(float value) : m_Value(value) {}
// 虚函数
virtual ~Abstract() {}
// 非虚函数
float GetValue() { return m_Value; }
// 静态函数
Static Abstract* GetInstance();
private:
// 非静态数据成员
float m_Value;
// 静态数据成员
static Abstract* m_Instance;
};
Abstract abstract;
printf("%d", sizeof(abstract));
// 内存布局
// vptr
// float
// pad (或有)
// 64位 16 = 4(float) + 8(虚表指针) + 4(对齐)
// 32位 8 = 4(float) + 4(虚表指针)一个实例对象,包含 非静态数据成员、虚表指针、为内存对齐而必须的填充,静态数据成员、函数独立于实例对象。
空对象
class Empty{
};
Empty empty;
printf("%d", sizeof(empty)); // 1
Empty arr[3]; // 若sizeof(Empty)=0,则arr[0]、arr[1]、arr[2]地址相同
// 内存布局
// 1地址唯一性要求 C++规定每个对象必须有唯一的地址。空类对象大小至少为1字节,只是为了区分实例对象。 空类大小为0会导致数组元素无法正确分隔。
空基类
class Derived : public Empty {
public:
int x;
};
Derived derived;
printf("%d", sizeof(derived)); // 4,空基类不占用额外空间
// 内存布局
// int**空基类优化(Empty Base Optimization, EBO)**派生类的内存布局中,空基类与首个数据成员共享地址空间。
内存对齐
手动指定
#pragma pack(n) // n 字节对齐
#pragma pack() // 恢复默认
#pragma pack(1) // 1 字节对齐
struct NetworkPacket {
uint8_t type;
uint32_t data; // 紧邻 type,无填充
};
#pragma pack() // 恢复默认对齐
sizeof(NetworkPacket) = 5手动修改内存对齐,作用域级别
__attribute__((aligned(n))) // 单独设置 n 字节对齐,GCC/Clang 特有(非标准 C++)
alignas(n) // C++11 标准提供
// 结构体整体按 16 字节对齐
struct Vector4f __attribute__((aligned(16))) {
float x, y, z, w;
};
// 单个成员按 8 字节对齐
struct Data {
char id;
int value __attribute__((aligned(8)));
};
`Vector4f`地址为 16 的倍数;`value`在 `Data`中的偏移为 8 的倍数手动修改内存对齐,声明级别
非静态数据成员声明顺序与内存对齐
相同访问控制级别(public protected private),更 靠后 的成员有更 高 的地址。 即内存布局和声明顺序一致。 对于不同访问控制级别,未作规定,由编译器自行实现。但实际上编译器也是按声明顺序进行处理。
变量顺序会直接影响 内存对齐。
不含虚表的继承
单继承
class A {
float x;
short y;
};
class B : public A {
short z;
};
sizeof(B); // 12 = A(4 + 2 + 2(对齐)) + B(2 + 2(对齐))
// 顺序
// A
// B类之间单独计算内存对齐。 C++ 保证,出现在 derived class 中的 base class subobject 有其 完整原样性。 否则,大的 object 赋值给小的 object,会引发 object 切割,将 大的object 的 subobject 赋值给 小的 object。
多继承
class A {};
class B {};
class C : public A, public B {};
// 内存布局
// A
// B
// C多重继承
class A {};
class B : public A {};
class C : public A {};
class D : public B, public C {};
// 内存布局
// B::A
// B
// C::A
// C
// D
// 菱形继承(特例),访问A需要指明,但与多重继承一致含虚表的继承
class A {
virtual void DoSomething();
virtual void DoNothing();
void NoVirtual();
virtual ~A();
};
// 虚表结构
// vptr -> 虚表
// A_type_info
// A::DoSomething
// A::~A (类中声明的)
// A::~A (编译器合成的,会调用上面的)
// A::DoNothing
class B : public A {
virtual void DoSomething() override;
};
// 虚表结构
// vptr -> 虚表
// B_type_info
// B::DoSomething
// B::~A (类中声明的)
// B::~A (编译器合成的,会调用上面的)
// A::DoNothing
// 虚表调用过程
(*ptr->vptr[n])(ptr)
// 菱形继承(特例),访问A需要指明,但与多重继承一致构造函数语义
默认构造生成规则
一些情况下,编译会定义 默认构造、拷贝构造、移动构造、拷贝复制运算符、移动复制运算符、析构成员函数 。
以下条件满足都满足时,编译器不会提供 默认构造
- 没有
虚函数、虚基类
无需设置虚表 - 所有
非静态数据成员都已经在声明时初始化 无需初始化值 - 所有
直接继承的基类都没有默认构造函数 无需调用基类的构造 - 所有
非静态的数据成员都没有默认构造 无需调用数据成员的构造
基类和数据成员的初始化时机
class A {
A(){}
};
class B : public A {
B(){
A::A(this); //由编译器扩充
A::A(&a); //由编译器扩充
std::string(&m_Str); //由编译器扩充
m_Str = "m_Str"; //函数自定义
}
B(const std::string& str) : m_Str(str) {
A::A(this); //由编译器扩充
A::A(&a); //由编译器扩充,按顺序(初始化成员列表的顺序问题)
m_Str(std::string(&str)); //由编译器扩充
}
A a;
std::string m_Str;
};构造是,从 低地址 -> 高地址 去构造
拷贝构造生成规则
以下条件均满足时,编译器不会实现 拷贝构造、移动构造
- 没有
虚函数、虚基类无需构造虚表 直接继承的基类没有拷贝构造 无需调用基类- 所有 含 类对象(包括容器) 的
非静态数据成员没有拷贝构造 无需调用成员的
析构函数语义
析构函数生成规则
以下条件满足都满足时,编译器不会提供 默认析构
- 所有 含 类对象(包括容器) 的
非静态数据成员没有析构 无需调用成员的析构 - 所有
直接继承的基类析构 无需调用基类的析构
数据成员 析构执行的顺序,与数据成员的 声明顺序 相反。 析构是,从 高地址 -> 低地址 去析构。
class A { ~A(){} };
class B { ~B(){} };
class C { ~C(){
A a,
B b,
} };
// 顺序
// C::~C
// B::~B
// B::~B函数调用原理
全局函数
step1 参数传递 step2 调用函数 step3 处理返回值
非静态非虚成员函数
class A { A(...){} }
// 实际执行逻辑
A::A(&a, ...) // 隐式传递 this 指针step1 参数传递 step2 把对象的首地址作为参数,调用函数 step3 处理返回值
构造函数、拷贝构造函数、析构函数、虚函数
step1 参数传递 step2 虚表跳转 step3 把对象的首地址作为参数,调用函数 step4 处理返回值