[C++]sizeof各种情况详细分析+内存补齐机制

sizeof操作符的作用是返回一个对象或类型名的长度，返回值的类型为size_t,长度的单位是字节。sizeof表达式的结果是编译时常量。

测试环境:win10 64位 dev c++

• 先上几个基本数据类型

short a;
int b;
float c;
long d;
double e;
long long f;
cout<<sizeof(a)<<endl;//2
cout<<sizeof(b)<<endl;//4
cout<<sizeof(c)<<endl;//4
cout<<sizeof(d)<<endl;//4
cout<<sizeof(e)<<endl;//8
cout<<sizeof(f)<<endl;//8

• 再看看数组和字符串这类

char a;
string b;
int c[10];
char d[]="abc";
cout<<sizeof(a)<<endl;//1
cout<<sizeof(b)<<endl;//8
cout<<sizeof(c)<<endl;//40  10个int 4字节=40
cout<<sizeof(d)<<endl;//4 还要算上末尾的NULL 3+1=4

• 再扯上指针

int f[10];
int *p=f;
cout<<sizeof(p)<<" "<<sizeof(*p)<<endl;
//指针大小我这里由于是64位 输出是8 ,输出4也是有可能的
//后面是输出指针指向的int型对象，即等于sizeof(int)=4

• 再试试看普通函数

int fun(){return 0;}
int main(){
    cout<<sizeof(fun())<<endl;//4 这里也是根据int型是4字节 得到的
    ...
}

• 该试试看类了,开始变得有趣了哦~

class classTest{    
    public:	
	int i;//4
        char c;//1
	short s;//2		 
};
int main(){
    cout<<sizeof(classTest)<<endl;//8
    ...
}

这里就单独拉出来分析吧，求类的大小的时候，会对类里的成员大小进行求和，根据我们上面做过的测试，我们可以很快得到int型4字节，char型1字节,short型2字节，那么这里为什么得到的是8字节呢？
先别急，我们接着再看一下对上式的稍稍改变

class classTest{    
	public:	
	    char c;//1
	    int i;//4
	    short s;//2		 
};
int main(){
    cout<<sizeof(classTest)<<endl;//12
    ...
}

咦？为什么改变了一下类成员i和c的位置，类占用内存大小怎么变成12了，这里我们就要牵扯到内存补齐的概念了。

在C语言中，结构是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如数组、结构、联合等）的数据单元。在结构中，编译器为结构的每个成员按其自然对界（alignment）条件分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。

上述的结构struct同样适用于class，我们现在重新对我们上面的代码进行分析

class classTest{    
	public:	
	    int i;//4
	    char c;//1
	    short s;//2		 
};

第一个成员i为int型，其自然对界为4，假设起始地址为0000，占据了4个字节，则现在使用了占用了0000-0003的地址。第二个成员c为char型,其自然对界为2，小于int型的自然对界，占据1个字节，所以占用了0004的地址。第三个成员s为short型，其自然对界为1，依旧小于最大的int型，即占用了0005-0006的地址，并且s和c还处于int型的自然对界地址上(2+1<4),然后在成员s后补一个空字节，补齐了字节对界 所以最后占用了0000~0007一共8个字节

再看第二段代码

class classTest{    
	public:	
	    char c;//1
	    int i;//4
	    short s;//2		 
};
int main(){
    cout<<sizeof(classTest)<<endl;//12
    ...
}

这里的第一个成员c是char型，其自然对界为1，假设起始地址为0000，占据了1个字节。第二个成员i是int型，其自然对界为4，大于char型的了,那大的就当老大了呗，int型就跟char型说你得按照我的格式来，所以char型没办法，地址0001-0003就被空字节补齐了，int型就从0004-0007占用了4个字节。第三个成员s是short型，其自然对界为2，还是没有int型大，所以地址从0008-0009是其两个字节的占用，0010-0011则用空字节补齐了。最后一共占用12个字节

我们来看看之前CSDN一道很火的题目

struct s1{
    short a;
    long b;
};
struct s2{
    char c;
    s1 d;
    long long e;
};

问题来了 sizeof(s2)答案是多少呢？
我们来逐步分析一下，首先对于sizeof(s1)如果你用之前的自然对界方法去内存补齐的话得到的结果将是8字节，然后我们再来专心看结构s2中。
首先c是char型占1个字节，其次我们由结构体s1声明了一个对象，它是8字节的，对于结构来说,它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个，
所以我们找到s1中最大的是long型 4字节，所以c会被自动补全至4个字节，在c和d之间存在3个空字节，截止到d这样就已经占用了12个字节了，接着e是long long型的占8个字节，因此自然对界就应该以8字节看齐，d和e之间就需要补齐4个字节，所以最终是24个字节占用

• 好像有点深入…我们回过头来,再继续对类中函数进行测试吧

class Base{            
	public:
		void normalprint(){}//函数不占用内存 
	private:
		int a;//4字节
};

对于上面的类sizeof(Base)结果是4，因为普通函数在类中不占用内存
有个结论就是：对象的大小是它的数据成员所占存储空间之和
那肯定有人会问那空类的大小是不是就是0了呢？显然，当类里没有任何真正的成员变量，所以大小应该是0，但0大小不好在内存中定位一个地址，所以就规定它大小为0的对象要占一字节空间，以便让它拥有一个合法的地址。

我们接着添加下派生类再试试

class Derived:public Base{
	public:
	private:
		int b; //4字节
};

sizeof(Derived)结果是8 这里是因为派生类大小=基类成员大小+派生类成员大小。(当然同样适用于内存补齐机制)

• 那扯上虚函数呢？！我们修改一下之前的基类

class Base{            
	public:
		virtual void print(){} //存在虚函数指针 占用8字节(系统原因也有可能是4字节)
		void normalprint(){}//函数不占用内存 
	private:
		int a;
};

sizeof(Base)答案是多少呢？之前说过普通函数在类中不占用字节，但是虚函数就不一样了，类里的虚函数其实是由一个指向虚函数表的vptr指针构成的，指针的大小我这里是8字节，所以这个虚函数大小就相等于存储了一个指针 所以一共是12字节咯？！！如果你认为是12字节那就说明之前讲的内存补齐机制没认真看！！！这里结果当然是16字节，详细解释自己翻一下上面介绍。
再看看派生类的情况呢？

class Derived:public Base{
	public:
		void print(){}
		virtual void d(){}
	private:
		int b; 

};

sizeof(Derived)答案是多少呢？你会不会这样算呢？首先派生类继承自Base的16字节，而派生类中虚函数d占用8个字节，再加上b的int型占用4个字节，如果我算上内存补齐b补全至8个字节，那答案就是32个字节咯！
很遗憾，答案是错的，首先有一个错误犯得很严重，派生类的虚函数指针其实是继承自基类的，在派生类中添加虚函数，并不表示添加了虚函数指针，而是给虚函数表上增添了一个地址。
其次第一句话派生类继承自Base的16个字节，其实就是错误的，我们知道派生类大小=基类成员大小+派生类成员大小，所以根据这一公式我们可以得到所含的是基类虚函数指针(8字节)+基类a(4字节)+派生类b(4字节)=16字节，当然这里由于正好内存补齐是16字节，如果派生类b是double类型的结果就又变了，这里大家可以自行去测试一下，结果应该是24。

总结

经过这次分析，你应该对sizeof有了深入了解了吧，我们还扩充了内存补齐机制和虚函数的相关知识！学习其实就应该像这样对一个问题的各种情况进行全面剖析，并且对于产生的原因进行更深层次的去探索，这样才能真正了解原理，今天就到这了，我们下次再见！