inside the C++ object model chapter 3 the semantics of data

大部分内容节选自inside the C++ object model，仅供个人学习使用

class X {};

class Y : public virtual X {};
class Z : public virtual X {};
class A : public Y, public Z {};

sizeof X yielded 1
sizeof Y yielded 8
sizeof Z yielded 8
sizeof A yielded 12

in practice is never empty. Rather it has an associated size of 1 byte—a char member inserted by the
compiler. This allows two objects of the class, such as
X a, b;
if ( &a == &b ) cerr << "yipes!" << endl;
to be allocated unique addresses in memory.

编译器会在空的类中插入char成员。这将允许该类的两个对象在内存中分配唯一的地址

1Language support overhead. There is an associated overhead incurred in the language support of virtual base classes. Within the derived class, this overhead is reflected as some form of pointer, either to the virtual base class subobject or to an associated table within which either the address or offset to the virtual base class subobject is stored. On my correspondent's machine, the pointer is 4 bytes.
(Virtual base classes are discussed in Section 3.4.)

2Compiler optimization of recognized special cases. There is the 1 byte size of the virtual base class X
subobject also present within Y (and Z). Traditionally, this is placed at the end of the "fixed" (that is,
invariant) portion of the derived class. Some compilers now provide special support for an empty
virtual base class (the paragraph following item 3 discusses this in more detail). Our correspondent's
compiler, however, did not provide this special handling.

1字节的虚基类X子对象也会出现在Y和Z中。通常这会放置在派生类的固定区域的末尾。

3. Alignment constraints. The size of class Y (and Z) at this point is 5 bytes. On most machines,
aggregate structures have an alignment constraint so that they can be efficiently loaded from and
stored to memory. On my correspondent's machine, alignment of an aggregate is on a 4-byte
boundary. So class Y (and Z) requires 3 bytes of padding. The result is a final size of 8.

sizeof （Y）

语言支持开销。支持虚基类会产生一个开销。在派生类中，这个开销会以指针的形式反映，或者指向虚基类子对象，或者指向存储虚基类子对象地址或偏移量的关联虚表

sizeof(A）的大小一方面也取决于编译器。通常情况下，

The size of the single shared instance of class X: 1 byte

1. Language support overhead. There is an associated overhead incurred in the language support of virtual base classes. Within the derived class, this overhead is reflected as some form of pointer, either to the virtual base class subobject or to an associated table within which either the address or offset to the virtual base class subobject is stored. On my correspondent's machine, the pointer is 4 bytes.
(Virtual base classes are discussed in Section 3.4.)

语言支持开销。语言支持虚基类会产生相关的开销。在派生类中，这个开销以某种形式的指针反映。该指针或者指向虚基类子对象，或指向存储虚基类子对象地址或偏移的

关联虚表
2. Compiler optimization of recognized special cases. There is the 1 byte size of the virtual base class X subobject also present within Y (and Z). Traditionally, this is placed at the end of the "fixed" (that is,invariant) portion of the derived class. Some compilers now provide special support for an empty virtual base class (the paragraph following item 3 discusses this in more detail). Our correspondent's compiler, however, did not provide this special handling.

3. Alignment constraints. The size of class Y (and Z) at this point is 5 bytes. On most machines,
aggregate structures have an alignment constraint so that they can be efficiently loaded from and
stored to memory. On my correspondent's machine, alignment of an aggregate is on a 4-byte
boundary. So class Y (and Z) requires 3 bytes of padding. The result is a final size of 8.

3.1 The Binding of a Data Member

the analysis of the member function's body is delayed until the entire class declaration is seen. Thus the
binding of a data member within the body of an inline member function does not occur until after the entire
class declaration is seen.

成员函数体的分析推迟直到整个类的声明被看见。因此内联成员函数体中数据成员的绑定直到整个类的声明被看见。

参数表中的名字被解析当该名字第一次被遇到的时候。

Names within the argument list are still resolved in place at the point they are first encountered.In the following code fragment, for example, the type of
length in both member function signatures resolves to that of the global typedef—that is, to int. When the subsequent declaration of the nested typedef of length is encountered, the Standard requires that the earlier bindings be flagged as illegal:

typedef int length;
class Point3d
{
public:
// oops: length resolves to global
// ok: _val resolves to Point3d::_val
mumble( length val ) { _val = val; }
length mumble() { return _val; }
// ...
private:
// length must be seen before its first
// reference within the class. This
// declaration makes the prior reference illegal.
typedef float length;
length _val;
// ...
};

3.2 Data Member Layout

the nonstatic data members are set down in the order of their declaration within each class object

The static data members are stored in the program's data segment independent of individual class objects.

3.4 Inheritance and Data Member

class Concrete1 {
public:
// ...
protected:
int val;
char bit1;
};
class Concrete2 : public Concrete1 {
public:
// ...
protected:
char bit2;
};
class Concrete3 : public Concrete2 {
public:
// ...
protected:
char bit3;
};

Concrete2 *pc2;
Concrete1 *pc1_1, *pc2_2;
Both pc1_1 and pc2_2 can address objects of either three classes. The following assignment
*pc1_1 = *pc2_2;
should perform a default memberwise copy of the Concrete1 portion of the object addressed. If pc1_1
addresses a Concrete2 or Concrete3 object, that should not be of consequence to the assignment of its
Concrete1 subobject.

*pc1_1=*pc2_2应该执行的是指针指向的对象的Concrete1部分的按成员拷贝。

However, if the language were to pack the derived class members Concrete2::bit2 or Concrete3::bit3 into the Concrete1 subobject, these language semantics could not be preserved.

注：开始理解的时候没有理解清楚pack的含义，还以为是将bit2 成员放到父类Concrete1里面。后来联系下上文

pack代表把bit2成员在内存对象中的布局直接跟在bit1后面，而bit1后面不使用填充的3字节，

这样Concrete2对象在内存中的布局便成为了

int val（4字节），char bit1（1字节），char bit2（1字节），padding（2字节）总共8字节。

而不是之前的

int val(4字节），char bit1(1字节），padding(3字节）（相当于Concrete1 subobject占据8字节),再加上char bit2（1字节），padding（3字节），共12字节

12字节这种方案是C++标准中的实现方案

pc1_1 = pc2;
// oops: derived class subobject is overridden
// its bit2 member now has an undefined value
*pc1_1 = *pc2_2，而复制是按子对象成员复制的，这样本来pc1_1指向的Concrete2对象的bit2成员对应的内存单元就会被pc2_2指向的对象的Concrete1

子对象的padding对应的内存单元给覆盖，导致pc2的bit2成员变成了某个未定义的值

The size of virtual table in general is the number of virtual functions declared plus an additional one or two slots to support runtime type identification

p68: to be continued