访问BlueStacks的应用程序（WhatsApp）数据库(Acessing BlueStacks' application (WhatsApp) database)

 size和align是作为完整类型使用时类的大小和对齐方式。 也就是说，如果创建了完整类型为该类型的对象（如定义该类型的变量或使用该类型的new类型）。 
 
 大小仅仅是它占用的字节数。 所以size=16意味着当用作完整类型时，它总是占用16个字节。 
 
 对齐方式告诉您可以放置​​对象的位置： align=8表示对象的地址必须是8的整数倍。 
 
 如果该类用作基类，则base size和base align提供大小和对齐方式。 它们之所以不同，是因为C ++标准允许对象在用作基类时使用较少的填充。 
 
 所以让我们看看你的例子（我假设你在第一种情况下在double之前实际上有int ）。 我也省略了public和private因为在这里它们不会改变任何东西（如果你有公共或私人数据成员，他们原则上可以改变某些东西，但我不知道是否有编译器利用这些）。 我也猜测int和double的大小和对齐（实际上我假设的值是非常常见的选择，并解释你得到的值）。 
 
 所以在第一种情况下（我假设）你有 
 
class A
{
  int m_number;
  double m_nothing;
};
 
 现在int具有大小和对齐4 ，而double具有大小和对齐8 。 
 
 那么让我们来完成编译器的工作并构建我们的类。 
 
 首先，我们有m_number ，它占用4个字节。 我们必须按照给定的顺序放置成员，所以m_number在A的开头： 
 
iiii
 
 到目前为止，我们的大小为4（int的四个字节）和对齐4（因为int具有对齐4）。 但是现在我们必须添加一个double（size和alignment 8）。 由于直接在int之后，我们在（相对）地址4处，我们没有正确地对齐double，所以我们必须添加4个填充字节（我将用*标记）以达到8的倍数。因此我们为我们的班级获得： 
 
iiii****dddddddd
 
 现在，如果这个类被用作基类，我们就完成了。 因此，我们需要base size=16和base align=8 （我们需要一个8的对齐才能正确地进行double对齐）。 
 
 对于完整的对象，还有另外一个考虑因素：标准要求在数组中，对象彼此相互之间没有间隙。 也就是说，对象之后的第一个字节必须正确对齐下一个对象。 这最终意味着完整对象的大小必须是其对齐的倍数。 
 
 现在我们发现的对象布局已经满足了这个要求。 因此，我们可以将它用于完整的对象。 因此，对于完整的对象，我们得到size=16和align=8 。 
 
 现在考虑顺序颠倒的情况： 
 
class A
{
  double m_nothing;
  int m_number;
};
 
 现在我们必须从double开始： 
 
dddddddd
 
 接下来，我们必须添加int 。 事实证明，下一个空闲的地方已经正确地对齐了一个int ，因此我们可以将它追加： 
 
ddddddddiiii
 
 现在作为基础对象使用，我们已经准备好了。 如您所见，我们只需要12个字节，因此base size=12 。 当然， double正确对齐，对象又必须从8的倍数开始。因此，我们有base align=8 。 
 
 然而，对于作为完整对象的起诉，我们现在发现下一个地址将位于12位，这对于double成员来说没有正确对齐。 因此，我们必须添加填充字节，直到我们再次到达正确对齐的地址： 
 
ddddddddiiii****
 
 正如你所看到的，现在我们需要16个字节，因此size=16 。 由于双倍，我们仍然有align=8 。 
 
 请注意，对齐要求会显着影响类的大小。 考虑以下两种类型： 
 
struct S1
{
  char c1;
  double d1;
  char c2;
  double d2;
  char c3;
};

struct S2
{
  double d1;
  double d2;
  char c1;
  char c2;
  char c3;
};
 
 虽然两者都包含相同的成员，但S1上面的大小和路线的总数（非基数）为40，而S2的总大小只有24个。事实上， S1类型的对象将作为完整对象， 看起来像 
 
c*******ddddddddc*******ddddddddc*******
 
 而S2型的则看起来像 
 
ddddddddddddddddccc*****
 
 因此，最重要的是，对齐要求最高的成员应始终排在第一位。 
 
 另请注意， sizeof返回完整对象的大小，即类层次转储调用的size 。 

The size and align are the size and alignment of the class when used as complete type. That is, if you create objects whose complete type is that type (like defining variables of that type, or using that type with new).
 
The size is simply the number of bytes it occupies. So size=16 means when used as complete type, it always occupies 16 bytes.
 
The alignment tells you where the object may be placed: align=8 means the address of the object must be an integer multiple of 8.
 
The base size and base align give the size and alignment in case the class is used as base class. The reason why they are different is that the C++ standard allows objects to use less padding when used as base class.
 
So let's look specifically at your example (I'm assuming that you actually have the int before the double in the first case). I'm also omitting the public and private because here they don't change anything (if you had both public or private data members, they could in principle change something, but I don't know if any compiler takes advantage of that). I'm also guessing the size and alignment of int and double (actually the values I assume are pretty common choice, and explain the values you get).
 
So in the first case (I assume) you have
 
class A
{
  int m_number;
  double m_nothing;
};
 
Now int has size and alignment 4, and double has size and alignment 8.
 
So let's do the job of the compiler and build our class.
 
First, we have m_number, which occupies 4 bytes. We have to put the members in the order given, so m_number goes at the beginning of A:
 
iiii
 
Up to now, we have size 4 (the four bytes for the int), and alignment 4 (because int has alignment 4). But now we have to add a double (size and alignment 8). Since directly after the int, we are at (relative) address 4, we are not correctly aligned for the double, so we have to add 4 padding bytes (which I'll mark with *) to get to a multiple of 8. Thus we get for our class:
 
iiii****dddddddd
 
Now, if the class is used as base class, we are finished. Thus we habe base size=16 and base align=8 (we need an alignment of 8 in order to get the double aligned correctly).
 
For the complete object, there's another consideration: The standard demands that in arrays, the objects follow each other without a gap in between. That is, the first byte after the object must be correctly aligned for the next object. Which ultimately means that the size of the complete object has to be a multiple of its alignment.
 
Now the object layout we've found already fulfils that requirement. Therefore we can use it unchanged also for the complete object. Therefore we get size=16 and align=8 for the complete object.
 
Now consider the case where the order is reversed:
 
class A
{
  double m_nothing;
  int m_number;
};
 
Now we have to start with the double:
 
dddddddd
 
Next, we have to add the int. As it turns out, the next free place is already correctly aligned for an int, therefore we can just append it:
 
ddddddddiiii
 
Now for the use as base object, we are ready. As you can see, we only needed 12 bytes, therefore base size=12. Of course for the double to be correctly aligned, the object again has to start at an address which is a multiple of 8. Therefore we have base align=8.
 
However for the sue as complete object, we now find that the next address would be at position 12, which is not correctly aligned for the double member. Therefore we have to add padding bytes until we reach a correctly aligned address again:
 
ddddddddiiii****
 
As you can see, now we need 16 bytes, thus size=16. We still have align=8 due to the double.
 
Note that the alignment requirement can dramatically affect the size of a class. Consider for example the following two types:
 
struct S1
{
  char c1;
  double d1;
  char c2;
  double d2;
  char c3;
};

struct S2
{
  double d1;
  double d2;
  char c1;
  char c2;
  char c3;
};
 
While both contain the same members, S1 will with the sizes and alignments above have a total (non-base) size of 40, while the total size of S2 will be just 24. Indeed, the objects of type S1 will, as complete object, look like
 
c*******ddddddddc*******ddddddddc*******
 
while those of type S2 will look like
 
ddddddddddddddddccc*****
 
So the bottom line is that members with the highest alignment requirement should always come first.
 
Also note that sizeof returns the size of complete objects, that is, what the class hierarchy dump calls size.