普通类型字节数

字节数对照表

结构体在内存中的对其规则

转载自：http://blog.csdn.net/grantxx/article/details/7577730
作者：grantxx

1. 例一

 #include <iostream>
 using namespace std;
struct X
 {
     char a;
     int b;
     double c;
}S1;
 void main()
{
      cout << sizeof(S1) << endl;
      cout << sizeof(S1.a) << endl;
      cout << sizeof(S1.b) << endl;
      cout << sizeof(S1.c) << endl;
 }

比如例一中的结构体变量S1定义之后，经测试，会发现sizeof(S1）= 16，其值不等于sizeof(S1.a) = 1、sizeof(S1.b) = 4和 sizeof(S1.c) = 8三者之和，这里面就存在存储对齐问题。
原则一：结构体中元素是按照定义顺序一个一个放到内存中去的，但并不是紧密排列的。从结构体存储的首地址开始，每一个元素放置到内存中时，它都会认为内存是以它自己的大小来划分的，因此元素放置的位置一定会在自己宽度的整数倍上开始（以结构体变量首地址为0计算）。
比如此例，首先系统会将字符型变量a存入第0个字节（相对地址，指内存开辟的首地址）；然后在存放整形变量b时，会以4个字节为单位进行存储，由于第一个四字节模块已有数据，因此它会存入第二个四字节模块，也就是存入到4~8字节；同理，存放双精度实型变量c时，由于其宽度为8，其存放时会以8个字节为单位存储，也就是会找到第一个空的且是8的整数倍的位置开始存储，此例中，此例中，由于头一个8字节模块已被占用，所以将c存入第二个8字节模块。

2. 例二

 struct X
{
     char a;
     double b;
     int c;
 }S2;

在例二中仅仅是将double型的变量和int型的变量互换了位置。测试程序不变，测试结果却截然不同，sizeof(S2)=24，不同于我们按照原则一计算出的8+8+4=20，这就引出了我们的第二原则。
在经过第一原则分析后，检查计算出的存储单元是否为所有元素中最宽的元素的长度的整数倍，是，则结束；若不是，则补齐为它的整数倍。
例二中，我们分析完后的存储长度为20字节，不是最宽元素长度8的整数倍，因此将它补齐到8的整数倍，也就是24。这样就没问题了。

几个例子

struct X
 { 
      double a;
      char b;
      int c;     
}S3;//占用字节数：16

struct X
 { 
 double a;
 char b;
 int c;
 char d;   
 }S4;//占用字节数：24

struct X
{ 
   double a;
   char b;
   int c;
   char d;
   int e; 
}S5;//占用字节数：24

struct X
{ 
    int e;
    double a;
    char b;
    int c;
    char d;
}S6;//占用字节数：32

含有结构体成员的结构体

struct X
{
   char a;
   int b;
   double c;
 };
 struct Y
{
    char a;
    X b;
 };

经测试，可知sizeof(X)为16，sizeof(Y)为24。即计算Y的存储长度时，在存放第二个元素b时的初始位置是在double型的长度8的整数倍处，而非16的整数倍处，即系统为b所分配的存储空间是第8~23个字节。
由于结构体所占空间与其内部元素的类型有关，而且与不同类型元素的排列有关，因此在定义结构体时，在元素类型及数量确定之后，我们还应该注意一下其内部元素的定义顺序。

类大小的计算

1） 一般情况

class Test1
{
private:
int a;
int b;
};//sizeof(Test1)=8

2）含有普通成员函数的类

class Test2
{
public:
void SetXXX() { cout<<"Set"<<endl; } //成员函数
int GetXXX() { cout<<"Get"<<endl; }
private:
int a;
int b;
};//sizeof(Test2)=8

分析：大小为8，sizeof访问的程序的数据段，而成员函数地址则被保存在代码段内。

3）含有虚函数的类

class Test3
{
public:
virtual void Print() { cout<<"Virtual"<<endl; }
private:
int a;
int b;
};//sizeof(Test3)=12（32位系统）

分析：含有虚函数，则必有一个虚指针。指针是用来存放地址的，地址都是一个整型值，所以(32位系统中指针4字节，64位系统中指针8个字节) 32位系统中此类的大小为12字节

4）含有多个虚函数的类：

class Test4
{
public:
virtual void Print1() { cout<<"Virtual"<<endl; }
virtual void Print2() { cout<<"Virtual"<<endl; }
virtual void Print3() { cout<<"Virtual"<<endl; }
private:
int a;
int b;
};//sizeof(Test4)=12（32位系统）

分析：不管包含多少虚函数，但是虚指针只有一个，也就是+4字节（32位系统中）

5）空类

class Test5
{
};//sizeof(Test5)=1

分析：空类，C++会给类开一1个空间预留

6）含有静态成员的类

class Test6
{
private:
static int a;
};//sizeof(Test6)=1

分析：其实这个和上面的情况5是一样的，static是不属于类空间里面的，存放于静态区