结构体字节对齐
【例子】
结构体(struct)的sizeof值，并不是简单的将其中各元素所占字节相加，而是要考虑到存储空间的字节对齐问题。先看下面定义的两个结构体.
struct
{
char a;
short b;
char c;
}S1;
struct
{
char a;
char b;
short c;
}S2;
分别用程序测试得出sizeof(S1)=6, sizeof(S2)=4。可见，虽然两个结构体所含的元素相同，但因为其中存放的元素类型顺序不一样，所占字节也出现差异。这就是字节对齐原因。通过字节对齐，有助于加快计算机的取数速度，否则就得多花指令周期。
【字节对齐原则】
结构体默认的字节对齐一般满足三个准则：
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员自身大小的整数倍，如有需要编译器会在成员之间加上填充字节；
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节。
通 过这三个原则，就不难理解上面两个struct的差异了。对于struct S1, 为了使short变量满足字节对其准则(2), 即其存储位置相对于结构体首地址的offset是自身大小(short占2个字节)的整数倍，必须在字节a后面填充一个字节以对齐；再由准则(3),为了 满足结构体总大小为short大小的整数倍，必须再在c后面填充一个字节。对于struct S2, 却不必如上所述的填充字节，因为其直接顺序存储已经满足了对齐准则。
如果将上面两个结构体中的short都改为int(占4个字节), 那么会怎么样呢？程序得出sizeof(S1)=12, sizeof(S2)=8。利用上面的准则，也不难计算得出这样的结果。S1中在a后面填充3个字节、在c后面填充3个字节，这样一共12个字节；S2中 在a、b顺序存储之后填充两个字节用以对其，这样一共就8个字节。
还有一点要注意，“空结构体”（不含数据成员）的大小不为0，而是1。试想一个“不占空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢于是，“空结构体”变量也得被存储，这样编译器也就只能为其分配一个字节的空间用于占位了。如下：
struct S5 { };
sizeof( S5 ); // 结果为1
此外，对于空结构体(即内部没有任何元素),在UNIX平台gcc4.1下的sizeof 为0,而在Windows平台VC6下得出的sizeof却为1！我也不知道怎么回事，真是个有趣的现象!
【练习】
#include<stdio.h>
#pragma pack(4) // 必须在结构体定义之前使用
struct a
{
char no[10];
short q;
int p;
long int pp;
unsigned int ppp;
char x;
float y;
double h;
}xy;
void main()
{
printf("char=%d/n",sizeof(char)); //char = 1
printf("short=%d/n",sizeof(short)); //short = 2
printf("int=%d/n",sizeof(int)); //int = 4
printf("long int=%d/n",sizeof(long int)); //long int = 4
printf("unsigned int=%d/n",sizeof(unsigned int)); //unsigned int = 4;
printf("float=%d/n",sizeof(float)); //float = 4;
printf("doubl=%d/n",sizeof(double)); //double = 8;
printf("struct a: %d /n",sizeof(struct a));
}
Linux 下测试结果：
#pragma pack(1)
struct a: 37
#pragma pack(2)
struct a: 38
#pragma pack(3) //GCC警告：对齐边界必须是 2 的较小次方，而不是 3
struct a: 40
结果是按#pragma pack(4)来处理的。
#pragma pack(4)
struct a: 40
#pragma pack(8)
struct a: 40
Sizeof与Strlen的区别与联系
【几个例子】
例子1：
char* ss = "0123456789";
sizeof(ss) //4, ss是指向字符串常量的字符指针
strlen(ss) //10, 只能用它获得这个字符串的长度
char ss[] = "0123456789";
sizeof(ss) //11, ss是数组，计算到‘/0’位置，因此是10＋1
strlen(ss) //10, strlen是个函数内部实现是用一个循环计算到/0为止之前
char ss[100] = "0123456789";
sizeof(ss) //100, ss表示在内存中的大小100×1
strlen(ss) //10, strlen是个函数内部实现是用一个循环计算到/0为止之前
int ss[100] = "0123456789";
sizeof(ss) //400, ss表示再内存中的大小100×4
strlen(ss) //错误, strlen的参数只能是char* 且必须是以‘/0‘结尾
例子2：
class X
{
int i;
int j;
char k;
};
X x;
cout<<sizeof(X)<<endl; 结果 12 内存补齐
cout<<sizeof(x)<<endl; 结果 12 同上
例子3：
char szPath[MAX_PATH]
如 果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，但是将szPath作为虚参声明时（void fun(char szPath[MAX_PATH])）,sizeof(szPath)却会是4(指针大小)，即如果操作数是函数中的数组形参或函数类型的形 参，sizeof给出其指针的大小。
【sizeof 与strlen区别总结】
1.sizeof是运算符，strlen是函数。
2. strlen是有效字符串的长度，不包含‘/0’，与初始化有关系，而sizeof与初不初始化没有关系
3.sizeof可以用类型做参数，用来计算类型占内存大小，strlen只能用char*做参数，且必须是以'/0'结尾的，用来计算字符串的长度；
4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。
5. sizeof在编译时计算，而strlen的结果在运行时才能计算出来，
【课堂测试】
1. 如下程序的输出是什么？（在intel x86(32-bit) platform.）
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
int main( )
{
char str[10];
char *p;
memset(str,0x00,sizeof(str));
p = (char *)malloc(100);
printf("%d/n",sizeof(p));
printf("%d/n",sizeof('p'));
printf("%d/n",strlen(str));
exit(0);
}
答：4/1 /0, 如果不加memset()，第三行就会打出15（随机数），请问这是为什么？memset函数是初始化分配的内存空间，使用0、0x00都是0 即’/0'，不同系统当分配一块内存时，这块内存中的内容是未知的，系统只是根据申请者的要求为其化一块内存并不管他原先的内容是什么（有的系统清零）， 所以你的是随即数15。
2 ．你能够正确的说出它们的sizeof和strlen的大小吗？
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
int main( )
{
char *str1="absde";
char str2[]="absde";
char str3[8]={'a',};
char str4[8]={'a','b','s','e','f','g','h','j'};
printf("sizeof(str1)=%d/n",sizeof(str1));
printf("sizeof(str2)=%d/n",sizeof(str2));
printf("sizeof(str3)=%d/n",sizeof(str3));
printf("sizeof(str4)=%d/n",sizeof(str4));
printf("strlen(str1)=%d/n",strlen(str1));
printf("strlen(str2)=%d/n",strlen(str2));
printf("strlen(str3)=%d/n",strlen(str3));
printf("strlen(str4)=%d/n",strlen(str4));
exit(0);
}
答：sizeof是计算括号中变量的类型所占的储存空间(不考虑内容)；strlen是计算变量值为起点的内存地址到第一个'/0'的距离，以字节为单位，字符串尾部为'/0',0=='/0'（不包括’/0’）。正确答案是：4、6、8、8；5、5、1、9；
3. 你能够正确的说出它们的sizeof和strlen的大小吗？
char *str1="absde";
char str2[]="absde";
char str3[8]={'a',};
char str4[8]={'a','b','s','e','f','g','h','j'};
答案：
sizeof(str1)=4;
sizeof(*str1)=1;
strlen(str1)=5;
sizeof(str2)=6;
strlen(str2)=5;
sizeof(str3)=8;
strlen(str3)=1;
sizeof(str4)=8;
strlen(str4)=13;
strlen(*str1) 出错
strlen(str4)有可能为不小于8的其他数字，取决于内存中的数据，因为strlen是计算变量值为起点的内存地址到第一个'/0'的距离，但'/0'出现位置我们是未知的。
关于Sizeof
一、 sizeof 的概念
sizeof 是C语言的一种单目操作符，如C语言的++、--等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括 在括号内的类型名。操作数的存储大小由操作数的类型决定。其实可以简单的理解sizeof是征对"类型"的。
二、 sizeof 的使用方法
1、用于数据类型
sizeof使用形式：sizeof（type），数据类型必须用括号括住。如sizeof（int）。
2、用于变量
sizeof使用形式：sizeof（var_name）或sizeof var_name
变量名可以不用括号。如sizeof (var_name)，sizeof var_name等都可以。带括号的用法更普遍，大多数程序员采用这种形式。
注意：sizeof操作符不能用于函数类型，不完全类型或位字段。不完全类型指具有未知存储大小的数据类型，如未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。
三、 sizeof 的结果
sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。
1、若操作数具有类型char、unsigned char或signed char，其结果等于1。因为ANSI C正式规定字符类型为1字节。
2、 int、unsigned int 、short int（short）、unsigned short 、long int（long） 、unsigned long 、float、double、long double类型的sizeof 在ANSI C中没有具体规定，大小依赖于实现，一般可能分别为2、2、2、2、4、4、4、8、10。
3、当操作数是指针时，sizeof依赖于编译器。例如Microsoft C/C++7.0中，near类指针字节数为2，far、huge类指针字节数为4。一般Unix的指针字节数为4。
4、当操作数具有数组类型时，其结果是数组的总字节数，特别要注意字符串数组，如：
Char str[]=“123456” sizeof(str)=7。
5、联合类型操作数的sizeof是其最大字节成员的字节数。结构类型操作数的sizeof是这种类型对象的总字节数，包括任何垫补在内。
让我们看如下结构：
struct {char b; double x;} a;
在某些机器上sizeof（a）=16，而一般sizeof（char）+ sizeof（double）=9。
这是因为编译器在考虑对齐问题时，在结构中插入空位以控制各成员对象的地址对齐。
6、如果操作数是函数中的数组形参或函数类型的形参，sizeof给出其指针的大小。
即：int func(char p[100])
{ sizeof(p) = 4; }
C/C++中不能传数组,只能传指针,所以任何数组都会隐式转成指针形式进行操作,所以"类型"还是指针。
7．sizeof是运算符 当编译器编译时会自动运算这个变量的大小的 并使用它的大小代替sizeof的值如
int len = sizeof(int);编译时 编译器计算出int的大小 大小为4 所以把上面这句变成
int len = 4
四、 sizeof 与其他操作符的关系
sizeof的优先级为2级，比/、%等3级运算符优先级高。可与其他操作符一起组成表达式。如i*sizeof（int）；其中i为int类型变量。
五、 sizeof 的主要用途
1、sizeof操作符的一个主要用途是与存储分配和I/O系统那样的例程进行通信。例如：
void *malloc（size_t size）,
size_t fread(void * ptr,size_t size,size_t nmemb,FILE * stream)。
2、sizeof的另一个的主要用途是计算数组中元素的个数。例如：
void *memset（void *s,int c,sizeof(s)）。
3.在动态分配一对象时,可以让系统知道要分配多少内存。
如：int *p=(int *)malloc(sizeof(int)*10);
4.由于操作数的字节数在实现时可能出现变化，建议在涉及到操作数字节大小时用sizeof来代替常量计算。
5.如果操作数是函数中的数组形参或函数类型的形参，sizeof给出其指针的大小。
六、建议
由于操作数的字节数在实现时可能出现变化，建议在涉及到操作数字节大小时用ziseof来代替常量计算。
堆和栈的联系与区别
在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。 首先，我们举一个例子：
void f() { int* p=new int[5]; }
这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是： 在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：
00401028 push 14h
0040102A call operator new (00401060)
0040102F add esp,4
00401032 mov dword ptr [ebp-8],eax
00401035 mov eax,dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4],eax
这 里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。 好了，我们回到我们的主题：堆和栈究竟有什么区别？主要的区别由以下几点：
1、管理方式
对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
2、空间大小
一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在 VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：打开工程，依次操作菜单如 下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
3、碎片问题
对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先 进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数 据结构，这里我们就不再一一讨论了。
4、生长方向
对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
5、分配方式
堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
6、分配效率
栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则 是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索 可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小 的内存，然后进行返回。显然，堆的效率比栈要低得多。
从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态 和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地 址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。 虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就 算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的 :) 对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵, 清楚了？
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
