sizeof浅析（三）——求类的大小

95 阅读 0 评论 63 点赞

我是靠谱客的博主善良牛排，这篇文章主要介绍sizeof浅析（三）——求类的大小，现在分享给大家，希望可以做个参考。

sizeof求类的大小和求结构体的大小，有一定的相似性，但又不完全相同，因为类存在这继承和派生、存在着虚函数。

1、空类大小

对于一个空类，使用sizeof求得其大小为1。

2、简单类

如下定义一个类，

复制代码

1
2
3
4
5
6
7
class A
{
public:
int a;
private:
char b;
};

使用sizeof求这种简单类，结果和求结构体的sizeof是一样的，需要考虑偏移和对齐。要注意的是static变量不属于类的一部分，如果类中定义了static变量，求sizeof时可以忽略它们。

3、带虚函数的类

虚函数放在虚表中，类中定义了虚函数，需要存放一个指向虚表的指针。

复制代码

1
2
3
4
5
6
7
class A
{
public:
int a;
virtual void f(){}
};

上述代码的sizeof结果为sizeof(A.a)+sizeof(指针)。

当有多个虚函数时，仍然只需要一个指向虚表的指针，因此如下代码的结果和上述代码一样：

复制代码

1
2
3
4
5
6
7
8
class A
{
public:
int a;
virtual void f(){}
virtual void f2(){}
virtual void f3(){}
};

4、普通继承

复制代码

1
2
3
4
5
6
7
8
9
10
class A
{
public:
int a;
char b;
};
class B
{
char c;
};

上述代码结果取决于编译器，比如在Codeblocks中结果为8，这说明将char c和char b放到一起了，而在VS2010中，结果为12。不过对如下代码：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
class A
{
public:
int a;
private:
char b;
};
class B : public A
{
public:
int d;
char c;
};

Codeblocks和VS2010返回的结果都是12。

一般来说，普通继承的空间计算结果应当是sizeof(基类)+sizeof(派生类)，然后考虑对齐，内存空间必须是类中数据成员所占用最大空间的整数倍。不过这是一般情况，具体怎么算要看编译器，比如将上述代码中B的两个数据成员交换位置，结果则可能不同。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
class A
{
public:
int a;
private:
char b;
};
class B : public A
{
public:
char c;
int d;
};

对于Codeblocks，值不变，仍然为12，但对于VS2010，返回的结果是16。在这点上看，可能Codeblocks为程序分配的的内存要小于VS。

5、普通继承含虚函数的父类

复制代码

1
2
3
4
5
6
7
8
9
10
11
class Test
{
public:
char a;
virtual void get(){}
};
class Test2 : public Test
{
public:
int a;
};

求法和上面一样，sizeof(基类)+sizeof(派生类)，考虑对齐。上述代码在Codeblocks和VS2010下都是12。

6、含虚函数的子类普通继承含虚函数的父类

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
class Test
{
public:
int a;
virtual void get(){}
};
class Test2 : public Test
{
public:
int a;
virtual void set(){}
};

这个要注意的一点是，虽然子类和父类都包含虚函数，但它们存放于同一个虚表中，因此只需要一个指针，因而结果是sizeof(基类)+sizeof(派生类)-sizeof(指针)。上述代码在Codeblocks和VS2010下都是12。

如果子类或父类中有多个虚函数，怎么计算呢？按照3中所述，结果不变，如下代码证明这一点

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Test
{
public:
int a;
virtual void get(){}
virtual void ge2(){}
virtual void get3(){}
};
class Test2 : public Test
{
public:
int a;
virtual void set(){}
};

在Codeblocks和VS2010下都是12。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Test
{
public:
int a;
virtual void get(){}
};
class Test2 : public Test
{
public:
int a;
virtual void set(){}
virtual void set2(){}
virtual void set3(){}
};

仍然是12。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Test
{
public:
int a;
virtual void get(){}
virtual void ge2(){}
virtual void get3(){}
};
class Test2 : public Test
{
public:
int a;
virtual void set(){}
virtual void set2(){}
virtual void set3(){}
};

结果一样。

结论，在普通继承下，不管是子类还是父类包含虚函数，子类的sizeof=sizeof(基类数据成员)+sizeof(派生类数据成员)+sizeof(指针)。

7、子类虚继承父类

虚继承比较特别，一般的计算公式应当是sizeof(子类)=sizeof(基类)+sizeof(虚表指针)+sizeof(子类数据成员)。

如下代码是普通虚继承，不带虚函数：

复制代码

1
2
3
4
5
6
7
8
9
10
class A
{
public:
int a;
};
class B : virtual public A
{
public:
int b;
};

上述代码在Codeblocks和VS2010下sizeof结果都是12，基类A大小为4，子类B数据成员为4，因为是虚继承，可能需要一个指向虚基类的指针，再占用4字节，得到12。

然而，对于包含虚函数的子类虚继承不含虚函数的父类时，结果发生了变化：

复制代码

1
2
3
4
5
6
7
8
9
10
11
class A
{
public:
int a;
};
class B : virtual public A
{
public:
int a;
virtual void set(){}
};

在Codeblocks下结果仍为12，VS2010下却为16。子类增加了一个虚函数，Codeblocks下结果不变，在VS下结果却发生了变化。

可以这样认为，在VS下，计算公式可能如下：sizeof(子类)=sizeof(基类)+sizeof(指示虚基类的指针)+sizeof(子类数据成员)+sizeof(虚表指针)。在CB下可能对内存进行了优化（个人推测）

对于子类和父类中都含虚函数的虚继承，结果如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
class Test
{
public:
int a;
virtual void get(){}
};
class Test2 : virtual Test
{
public:
int a;
virtual void set(){}
};

在Codeblocks下结果为16，VS2010下为20。

这是因为，使用了虚继承，子类和父类的虚函数存放在不同的虚表中，因此子类和父类都需要一个指向虚表的指针。

8、多重继承

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class A
{
public:
int a;
};
class B :
public A
{
public:
int b;
};
class C : public A
{
public:
int c;
};
class D : public B, public C
{
public:
int d;
};

这个简单，就是基类的简单相加。sizeof(D)=sizeof(B)+sizeof(C)，在CB和VS下都是20。

9、多重虚继承

虚继承存在的意义就是为了减少内存开销和二义性，实现对象共享。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class A
{
public:
int a;
};
class B :
virtual public A
{
public:
int b;
};
class C : virtual public A
{
public:
int c;
};
class D : public B, public C
{
public:
int d;
};

sizeof(D)在CB和VS下都是24。D中包含a,b,c,d四个数据成员，还包含两个指向虚基类A的指针，这种情况下，VS和CB都没有将两个指针合为一个。这种情况也可以这样考虑，sizeof(D)=sizeof(B)+sizeof(C)，但由于是虚继承，虚基类A中数据成员a只需要保留一份，而我们算了两次，所以还需要减去A的数据成员，所以公式应当是sizeof(D)=sizeof(B)+sizeof(C)-sizeof(A的非静态数据成员)。

参考自：http://blog.sina.com.cn/s/blog_728161840100u2ib.html

——The End——