sizeof与strlen

piaoyedu 2013-08-11

展开全文

SIZEOF

表示形式：sizeof(变量或数据类型名)

根据作用对象的不同，下面我们将一一介绍：

数据类型：

不同数据类型所占字节数：bool,char占1字节，8位；short,int,long,float占4字节，double占8字节。

变量：

sizeof后面的括号可以省略。

指针：

指针均可看作变量的一种，所有指针变量的sizeof结果均为4，

int *a=new int[50];sizeof(a)=4;

数组：

对于静态数组，sizeof可以直接计算数组所占内存的大小，

int a[10]; sizeof(a)=40;

char b[]="hello";sizeof(b)=6;

注意：数组做形参时，数组名当指针使用，

void fun(fun(char p[]);

sizeof(p)=4;

结构体：

#include "stdio.h"
#include "string.h"
#include "stdlib.h"
int main()
{

  short int sa=10;
   int a=10;
   long la=10;
   float f = 20;
   double d=20;
   char ch='c';
   char str[]="ABC";
   char *p=str;
   struct str{
  double d;
  char ch;
  int data;
}str_wu;
struct str1{
  char ch;
  double d;
  int data;
}str_wu1;
printf("sizeof(short):%d\n",sizeof(sa));
printf("sizeof(int):%d\n",sizeof(a));
   printf("sizeof(long):%d\n",sizeof(la));
   printf("sizeof(float):%d\n",sizeof(f));
   printf("sizeof(double):%d\n",sizeof(d));
   printf("sizeof(char):%d\n",sizeof(ch));
   printf("sizeof(string):%d\n",sizeof(str));
   printf("sizeof(point address):%d\n",sizeof(p));
   printf("sizeof(Point):%d\n",sizeof(*p));
   printf("sizeof(Struct):%d\n",sizeof(str_wu));
   printf("sizeof(Struct):%d\n",sizeof(str_wu1));
   system("pause");
}

上面程序的运行结果是：2,4,4,4,8,1,4,4,1,16,24。前9个结果我们都可以接受，唯一困惑的就是最后两个，下面我们将进行详细的解释。

两个不同的结构，但是内部的元素是相同的，都是double，int，char，只是顺序不一样，就结果不一样。why？

这时因为VC存储数据的时候要对齐，具体的情况如下：

类型对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）

Char 　　偏移量必须为sizeof(char)即1的倍数

int 　　偏移量必须为sizeof(int)即4的倍数

float　　偏移量必须为sizeof(float)即4的倍数

double 　偏移量必须为sizeof(double)即8的倍数

Short　　偏移量必须为sizeof(short)即2的倍数

比如：str_wu，为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof(int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8 1 3 4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。所以整个结构的大小为：sizeof(str_wu)=8 1 3 4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

而str_wu1，同样的道理：如下：sizeof(char)=1,而1不是8的倍数，因而增加到8，sizeof（double）＝8，现在开始地址是16，16是sizeof（int)的倍数，可以存入。

因而总的地址数：sizeof（char）＋7＋sizeof（double）＋sizeof（int）＝20，

而20不是8的倍数（sizeof(double)=8),所以需要在增加4个地址，即总共24。

于是就产生了不同的结果。

VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。

VC中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；

否则必须为n的倍数。下面举例说明其用法。

#pragma pack(push) //保存对齐状态

#pragma pack(4)//设定为4字节对齐

struct test

{

char m1;

double m4;

int m3;

};

#pragma pack(pop)//恢复对齐状态

以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。

STRLEN

原型：extern unsigned int strlen(char *s)

头文件：string.h

格式：strlen(字符数组名)

功能：计算字符串s的长度，不包括‘\0’在内

说明：返回s的长度，不包括结束符NULL

SIZEOF与STRLEN的区别

1.sizeof是算符，strlen是函数；

2.sizeof可以用类型作参数，strlen只能用char*作参数，且必须是以“\0”结尾；

3.sizeof是计算对象使用内存的大小，不因存储内容的改变而改变；

srlen是计算字符串的长度；

4.大部分程序在编译阶段就把sizeof计算过了，而strlen的结果要在运行的时候才能计算出来；

5.sizeof后面如果是类型必须加括号，如果是变量名可以不加括号，不加括号的原因是：sizeof是个操作符而不是个函数。

6..数组做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（随机数），请问这是为什么？

因为strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。

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.经典问题：

      double* (*a)[3][6];
      cout<<sizeof(a)<<endl; // 4 a为指针
      cout<<sizeof(*a)<<endl; // 72 *a为一个有3*6个指针元素的数组
      cout<<sizeof(**a)<<endl; // 24 **a为数组一维的6个指针
      cout<<sizeof(***a)<<endl; // 4 ***a为一维的第一个指针
      cout<<sizeof(****a)<<endl; // 8 ****a为一个double变量