C语言中sizeof与strlen区别

一.本质区别
sizeof 和 strlen 有本质上的区别。sizeof 是C 语言的一种单目运算符，如++ 、-- 等，并不是函数，sizeof 的优先级为2 级，比/ 、% 等3 级运算符优先级高，sizeof 以字节的形式给出操作数的存储空间的大小。而strlen 是一个函数，是由C 语言的标准库提供的。strlen 计算的 是字符串的长度。
二.使用区别
1.sizeof
sizeof 的操作数可以是数据类型、函数、变量，表达式使用方式为：
（1）数据类型 sizeof  （type ）
例如我们要计算一个int 型数据的存储空间可以用：sizeof  （int）。需要注意的是 sizeof 的操作数是数据类型时要加括号。其数值大小为该数据类型所占的存储空间的字节数。
 （2）变量 sizeof （变量名）
如果定义  int  a ，可以使用sizeof（a ）计算a 变量占据的存储空间。具体大小 与a 的类型有关。
注意：由于sizeof 是操作符sizeof a 或sizeof（a ）都可以。（可以不使用括号）， 如果操作数是数组名则给出数组所占用内存的字节数。如果数组名做函数的参数传递时退化为指针。
（3）表达式 sizeof  （表达式）
sizeof 可以对一个表达式求值，编译器根据表达式的最终结果类型来确定大小， 一般不会对表达式进行计算。例如：sizeof（1+1.5）
 （4 ）函数调用 sizeof （函数名（））
sizeof 也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用，举例来说定义如下函数：
int myprint （）
{
  printf （“hello\n” ）；
  return 0;
}
int main()
{
 printf(“%d”,sizeof(mypaint()));
 return 0;
}
结果只打印函数返回类型的sizeof 值，并没有打印hello 说明函数myprint 并没有调用。
C99  标准规定，函数、不能确定类型的表达式以及位域（bit-field ）成员不能被 计算sizeof 值，即下面这些写法都是错误的：
如：sizeof   （myprint ）
（注意sizeof     （myprint  （）是可以的））
或者sizeof 一个void 返回类型的函数如：
void foo () { }
sizeof( foo () );
    以及位域：
struct S
{
unsigned int f1 : 1;
unsigned int f2 : 5;
unsigned int f3 : 12;
};
sizeof( S.f1 );
2.strlen
strlen 的应用则不像sizeof 那么广泛，strlen 的参数必须是char * 的指针，如果用 strlen 计算数据类型strlen（int ）这种用法是错误的。strlen 的计算必须依赖字符序列中的’\0’字符，strlen就是通过判断是否遇到’\0’来判断字符序列是否结束的。 它的计算原理类似于下面的两条语句
while （*p ！=’\0’ ）
   length++
strlen 的用法：分为以下几种参数
 （1）char *  指针
strlen （指针名） 
如果参数是指针则计算该指针指向字符序列的长度。（以’\0’作为判断标志）例如： 定义char *p=“hello world” ；strlen  （p ）=11 ，而sizeof（p ）=4 。可以看到strlen计算的是指针指向的字符串的长度而 sizeof  计算的是指针本身所占用的内存空间的大小。
 （2 ）数组 strlen（数组名）
如果参数是数组的话，实际传递的是一个指针，strlen 会按照上面处理指针的模式处理该数组。
我们可以看下面的例子：
char a[]=”hh”;
       strlen(a);
很显然strlen 的结果是2 。但是如果数组是这样赋值的呢？
char a[]={‘h’，’h’};
       strlen(a);
那么现在strlen（a ）的结果又是多少呢？这个数就不一定了，原因是strlen 会去计算a 地址开始的字符串的长度，由于前一种赋值方式会将hh  以字 符串的形式赋值给数组会将字符串结束符’\0’一同赋值，这时 strlen  就会检查到结束符停止计算，而第二种复值方式是以单个字符的形式赋值没有结束 符’\0’,这时我们用sizeof 得到的结果是正常的，而用 strlen  由于找不到结束符，会继续的计算直到找到结束符为止。所以这个数是不确定。 
sizeof() 和strlen() 简析
关于sizeof() 运算符和 strlen() 函数很多人都在遇到的时候时常时常搞不清，所以简要的讲解下。
首先两个有点相似性，可以用来计算大小。
sizeof() 运算符：
它的计算的是所占空间的总大小，一般变量定义之后就确定了。
#include<iostream>
using namespace std;
int main()
{
 int a[100];
char c;
 cout<<sizeof(a)<<endl;
 cout<<sizeof(c)<<endl;
}
结果是 4*100，1 ，以为字符型只占一个字节。
如果换成 char str[]=”0123”;
结果就是 5 ，因为这是一个字符串数组，除了四个数字外还有一个字符串结束标志 ‘\0’ 。这里和 strlen() 有点区别，稍后介绍到, sizeof() 是不会管你字符是否是结束符，只管你占用的空间罢了。
还有就是 char str[100]=”0123”;
sizeof(str)=100; (原先分配的空间是100)。
上面说的都是变量情况，如果计算的是指针的话，就要变下.
如：
 char *p=NULL;
 char *p=”0123”;
则 sizeof(p)=?
这个就不好判断了，得看你的机子是多少字长的，32字长则是 4，同理64 字长就是 8，这个貌似考试很喜欢考。
因为 p 是指针，属于地址，不一样。相似的情况还有函数形参传递的是地址也会出现这种情况。
#include<iostream>
using namespace std;
void fun(int array[])
{
 cout<<sizeof(array)<<endl;
}
int main()
{
 int array[5];
 fun(array);
 return 0;
}
结果为：4
最后一种情况，属于内存补齐，稍微注意下即可。
struct node
{
 int x;
 int y;
  char z;
}’
sizeof(node)=?
答案是12=4+4+4；这就属于内存补齐情况。

下面到了 strlen() 函数：
这个函数的处理机制是到 ‘\0’ 停止，所以‘\0’ 的作用就不能忽视了。
不过得注意这个是字符处理函数，不要用错了。
char str[]=”abcd”;
strlen(str)=4;

char str[]=”abcd\0abcd”;
strlen(str)=4;

char str[]=”0123\001234”;
strlen(str)=8;
最后一个注意 ‘\0’ 的意义已经变了，不是结束符，而是转义符。
关于 strlen() 主要强调一点，它是统计字符直到 ‘\0’ 才结束。
int a = -1;
sizeof(a=3); // = sizeof(a) = sizeof(int) = 4
cout<<a<<endl; //输出-1。由于sizeof()里面的表达式或者函数不执行， “=”操作符返回左操作数的类型，赋值操作没有执行。

sizeof分析
1. 在32位系统中不同类型的内存分配
1.1 基本类型
Cpp代码：
1. sizeof(int);         // = 4
2. sizeof(double);   // = 8
3. sizeof(char);       // = 1
4. sizeof(bool);       // = 1
5. sizeof(short);     // = 2
6. sizeof(float);      // = 4
7. sizeof(long);      // = 4
1.2 指针
指针在32位系统中占4个字节。
Cpp代码 ：
1. sizeof(int *);         // = 4
2. sizeof(double *);      // = 4
3. sizeof(char *);        // = 4
1.3 数组
1.3.1 数组的sizeof返回整个数组所占的字节数，即（数组元素个数×每个元素所占字节）。
Cpp代码：
1. int ai[] = {1, 2};
2. sizeof(ai);          // = 2*4 = 8
1.3.2 常量字符串与字符数组的内存分配方式相同。
Cpp代码：
1. char ac[] = "abcd";  //注意数组末尾的字符串终结符'\0'
2. sizeof(ac);          // = 5*1 = 5
3. sizeof("abcd");      // = 5*1 = 5
1.3.3 数组和指针所占的字节数不同，应注意区分。
1. int *pi = new int[10]; //这是指针
2. sizeof(pi);            // = 4
3. 
4. int ai[10];
5. int *p = ai;           //这还是指针
6. sizeof(p);             // = 4
7. 
8. double* (*a)[3][6];    //看成(double *) (*a)[3][6]，即一个3×6的二维数组，数组元素为指针，指向double类型。
9. sizeof(a);             // = 4，a为指向上述二维数组的指针
10. sizeof(*a);            // = sizeof(double *)*3*6 = 72，*a表示上述二维数组
11. sizeof(**a);           // = sizeof(double *)*6 = 24，**a即*(*a)，表示double*[6]，是元素为double指针的一维数组。
12. sizeof(***a);          // = sizeof(double *) = 4，表示上述一维数组中的第一个元素，元素类型为double指针。
13. sizeof(****a);         // = sizeof(double) = 8，表示上述数组首元素指向的double类型。
1.3.4 函数形式参数中的数组会蜕变为指针，原因是数组参数“传址调用”，调用者只需将实参的地址传递过去。有一种情况例外，那就是参数是指向数组的指针。
1. void acf(char p[3])     //参数类型是int[]，表示指向int的指针
2. {
3. sizeof( p );        // = 4
4. }
5. void aif(int p[])       //参数类型是int[]，表示指向int的指针
6. {
7. sizeof( p );        // = 4
8. }
9. void pif(int (*p)[6])   //参数类型是int (*)[6]，表示指向int数组的指针
10. {
11. sizeof( p);         // = 4
12. sizeof( *p );       // = sizeof(int)*6 = 24
13. }
14. void ppf(int *p[6])     //参数类型是int *[]，表示指向int指针的指针
15. {
16. sizeof( p );        // = 4
17. sizeof( *p );       // = 4
18. }
1.4. 类和结构体的内存分配。
1.4.1 空类或空结构体占一个字节。
Cpp代码
1. class CEmpty { };
2. sizeof(CEmpty); // = 1
3. 
4. struct SEmpty { };
5. sizeof(SEmpty); // = 1
1.4.2 非空类和结构体所占字节为所有成员占字节的和，但是不包括成员函数和静态成员所占的空间。
Cpp代码
1. class CInt : public CEmpty {
2. int i;
3. };
4. sizeof(CInt); // = 4;
5. 
6. class CFunc {
7. void f() {}
8. };
9. sizeof(CFunc); // = 1;
10. 
11. struct SInt : SEmpty {
12. static int i;
13. };
14. sizeof(SInt); // = 1;
1.4.3 字节对齐
为了加快计算机的取数速度，编译器默认对内存进行字节对齐。对结构体（包括类）进行字节对齐的原则是：
1）结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2）结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
3）结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。
Cpp代码
1. struct SByte1
2. {
3. double d;    // 偏移量0~7
4. char j;      // 偏移量8
5. int a;       // 偏移量12~15，由于9不能整除4，故先填充9~11
6. };
7. sizeof(SByte1);  // = 16
8. 
9. struct SByte2
10. {
11. char j;      // 偏移量0
12. double d;    // 偏移量8~15，由于1不能整除8，故先填充1~7
13. int a;       // 偏移量16~19
14. };
15. sizeof(SByte2);  // = 24，为了凑成8的倍数，填充20~23