【轉】C++類的sizeof大小

轉自https://blog.csdn.net/zhengjihao/article/details/77825269

其中有的描述與實際GCC上執行的結果不符，不過其中的分析思路需要掌握。

以下是GCC的實際執行結果：

#include <iostream>
using namespace std;

int *pointer;

class NullCls {};

class NullVirtual {
public:
    virtual void fun() {};
    virtual void fun2() {};
};

class CSI {
public:
    char b;
    short c;
    int a;
};

class CIS {
public:
    char b;
    int a;
    short c;
};

class CSV {
public:
    char b;
    short c;
    virtual void fun() {};
};

class CVS {
public:
    char a;
    virtual void fun() {};
    short b;
};

class StaticInt {
public:
    char b;
    virtual void fun() {};
    static int c;  // 放在程序的global data members中
};

class Method {
public:
    void fun() {};
};

class Parent {
public:
    int c;
};

class Son : public Parent {
public:
    int b;
};

class Parent2 {
public:
    int a;
    char b;
};

class Son2 : public Parent2 {
public:
    char c;
};

class A
{
    virtual void fun() {}
};

class B
{
    virtual void fun2() {}
};

class C : virtual public  A, virtual public B
{
public:
    virtual void fun3() {}
};

class C2 : public A, public B
{
public:
    virtual void fun3() {}
};

void size(string name, int s) {
    cout << name << "=" << s << endl;
}

int main(){
    size("pointer", sizeof(pointer));  // 8
    size("NullCls", sizeof(NullCls));  // 1
    size("NullVirtual", sizeof(NullVirtual));  // 8
    size("CSI", sizeof(CSI));  // 8
    size("CIS", sizeof(CIS));  // 12
    size("CSV", sizeof(CSV));  // 16
    size("CVS", sizeof(CVS));  // 16
    size("StaticInt", sizeof(StaticInt));  // 16
    size("Method", sizeof(Method));  // 1
    size("Son", sizeof(Son));  // 8
    size("Son2", sizeof(Son2));  // 12
    size("C", sizeof(C));  // 16
    size("C2", sizeof(C2));  // 16
}

 

《原文如下》

1空類

class A {};

大小為1。 

類的實例化就是給每一個實例在內存中分配一塊地址。空類被實例化時，會由編譯器隱含的添加一個字節。所以空類的size為1。
2 虛函數

class A
{
  public:
    virtual void fun() {};
    virtual void fun2() {};
};

大小為4。 

當C++類中有虛函數的時候，會有一個指向虛函數表(V-table)的指針，所有的虛函數都在這個表中。指針大小為4，所以size為4。

在來看如下代碼：

class A
{
  public:
    char b;
    short c;
    int a;
};
class B
{
  public:
    char a;
    int c;
    short b;
};

考慮數據對齊，大小分別為 8 和 12。如果我們將int換成虛函數，會是什么結果呢？

class A
{
public:
  char b;
  short c;
  virtual void fun() {}
};
class B
{
public:
  char a;
  virtual void fun() {}
  short b;
};

大小分別為 8 8。 都是占4個字節，結果不一樣。 這是因為，為了效率問題，編譯器(gcc 和 微軟)一般會把虛指針放在類的內存空間的最前面的位置，不管虛函數聲明的位置。考慮對齊，大小都是 4 +1+1+2 = 8.

3 靜態數據成員

class A
{
public:
  char b;
  virtual void fun() {};
  static int c;
};

大小為8。 

靜態數據成員被編譯器放在程序的一個global data members中，它是類的一個數據成員，但不影響類的大小。不管這個類產生了多少個實例，還是派生了多少新的類，靜態數據成員只有一個實例。靜態數據成員，一旦被聲明，就已經存在。 考慮到數據對齊， 最終是8字節。

4 普通成員函數

class A
{
public:
  void fun() {};
};

大小為1。 

類的大小與構造函數，析構函數，普通成員函數無關。

5 普通單繼承

class A 
{
  int c;
};
class B : public A
{
  int a;
};

大小分別為4 和 8。 可以看到普通的繼承就是基類的大小+派生類自身的大小。注意數據對齊。 

注意：類的數據成員按其聲明順序加入內存，無訪問權限無關，只看聲明順序。

class A
{
  int a;
  char b;
};
class C : public A
{
  public:
  char c;
};

上面這段代碼，不同的編譯器結果不同，VS的結果是 8 和 12， GCC是8 和 8。VS中 相當於

class C
{
  A a;
  char c;
};

A的大小為8，對齊值為4， 則考慮總體對齊 8 + 1 + 3(padding) = 12。 

GCC 則是

class C
{
  int a;
  char b;
  char c;
};

結果為 4 + 1 + 1 + 2 = 8。【與實際執行有出入】

6 含虛函數的單繼承

class A
{
  virtual void fun () {}
};
class C : public A
{
public:
  virtual void fun2() {}
};

大小分別為4 和 4。派生類繼承了基類的虛指針，所以大小為4。

7 虛單繼承

class A
{
  virtual void fun () {}
};

class C : virtual public A
{
public:
  virtual void fun2() {}
};

這段代碼，VS和gcc結果不一樣。VS為 4 和 12。 gcc為4 和4。

8 普通多繼承

class A
{
  int a;
  char b;
};

class B
{
  char b;
};
class C : public A, public B
{
public:
  char c;
};

VS：8 1 12 

GCC：8 1 8
VS中相當於把A B當做整體看待， GCC則拆分整合。

9 虛函數多繼承

class A
{
  virtual void fun() {}
};

class B
{
  virtual void fun2() {}
};
class C : public A, public B
{
public:
  virtual void fun3() {}
};

結果為 4 4 8。分析：類A一個虛函數表，類B一個虛函數表，類C繼承了兩個虛函數表，並把自己的虛函數寫在了繼承順序中第一個虛函數表中。

10 虛繼承

class A
{
  virtual void fun() {}
};

class B
{
  virtual void fun2() {}
};
class C : virtual public A, virtual public B
{
public:
  virtual void fun3() {}
};

GCC： 4 4 8   VS：4 4 16