sizeof与strlen()的用法与区别

sizeof

是在汇编里面就存在的一个指令，可以直接返回要判断的变量所占的内存大小（字节数），这是在编译器（编译阶段）就确定的。

返回值类型是size_t，该类型保证能容纳可以建立的最大对象的字节大小，在头文件 stddef.h 中定义。这是一个依赖编译系统的值，32位系统一般为： typedef unsigned int size_t; ，64位系统一般为： typedef unsigned long size_t; 。

sizeof的两种形式

sizeof(type_name); //sizeof(类型);
sizeof object; //sizeof 对象;

对类型和对象求值

int i;
sizeof(i); //ok
sizeof i; //ok
sizeof(int); //ok
sizeof int; //error

sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，同种类型的不同对象其sizeof值都是一致的。

对表达式求值

编译器根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。如：

sizeof(2); //2的类型为int，所以等价于sizeof(int);
sizeof(2 + 3.14); //3.14的类型为double，2也会被提升成double类型，所以等价于sizeof(double);

对函数调用求值

sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用，我们来看一个完整的例子：

char foo() {
    printf("foo()hasbeencalled.\n");
    return 'a';
}
int main() {
    size_tsz = sizeof(foo());
    //foo()的返回值类型为char，所以sz = sizeof(char)，foo()并不会被调用
    printf("sizeof(foo()) = %d\n", sz);
}

错误示例

C99标准规定，函数、不能确定类型的表达式以及位域（bit-field）成员不能被计算sizeof值，即下面这些写法都是错误的：

sizeof(foo); //error
void foo2(){}
sizeof(foo2()); //error
struct S {
    unsigned int f1:1;
    unsigned int f2:5;
    unsigned int f3:12;
};
sizeof(S.f1); //error

sizeof的常量性

sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用，如：

char ary[sizeof(int) * 10]; //ok

而C99标准规定sizeof也可以在运行时刻进行计算，如下面的程序在Dev-C++中可以正确执行：

int n;
n = 10; //n动态赋值
char ary[n]; //C99也支持数组的动态定义
printf("%d\n", sizeof(ary)); //ok.输出10

但在没有完全实现C99标准的编译器中就行不通了，上面的代码在VC6中就通不过编译。

所以我们最好还是认为sizeof是在编译期执行的，这样不会带来错误，让程序的可移植性强些。

sizeof之指针变量 vs. 数组变量

sizeof()的变量如果是指针char *，则返回指针本身的大小；如果是数组char []，返回的是数组空间的大小。

指针变量

在32位计算机中，一个指针变量的返回值通常是4（以字节为单位），在64位系统中指针变量的sizeof通常为8。

示例：

char *pc = "abc";
int *pi;
string *ps;
char **ppc = &pc;
void(*pf)(); //函数指针
sizeof(pc); //结果为4
sizeof(pi); //结果为4
sizeof(ps); //结果为4
sizeof(ppc); //结果为4
sizeof(pf); //结果为4

指针变量的sizeof值与指针所指的对象没有任何关系，所有的指针变量所占内存大小相等。

数组变量

数组的sizeof值等于数组所占用的内存字节数，如：

char a1[] = "abc"; 
int a2[3]; 
sizeof(a1); // 结果为4，字符末尾还存在一个'\0'结束符 
sizeof(a2); // 结果为3 * 4 = 12（依赖于int的大小）

求数组长度（个数）

int c1 = sizeof(a1) / sizeof(char); //总长度/单个元素的长度  char型
int c2 = sizeof(a2) / sizeof(a2[0]); //总长度/第一个元素的长度 int型

易错点！

函数形参列表里的数组本质是指针！！！

注意：在C++里，参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小。如果想在函数内知道数组的大小， 必须增加一个形参，将长度传进去。

示例：

void foo3(char a3[3]) {
    int c3=sizeof(a3); //c3 = ?
}
void foo4(char a4[]) {
    int c4=sizeof(a4); //c4 = ?
}

这里函数参数a3已不再是数组类型，而是蜕变成指针，相当于char* a3。试想：当我们调用函数foo3时，程序会在栈上分配一个大小为3的数组吗？不会！数组是“传址”的，调用者只需将实参的地址传递过去，所以a3自然为指针类型char*，c3的值也就为4。

结构体的sizeof

待补充。。。

从栈看sizeof

其实理解 sizeof 只需要抓住一个要点：栈。

程序存储分布有三个区域：栈、静态和动态。能够从代码直接操作的对象，包括任何类型的变量、指针，都是在栈上的；动态和静态存储区是靠栈上的所有指针间接操作的。

sizeof 操作符，计算的是对象在栈上的投影体积，记住这点很多东西都很清楚了。

char const *static_string = "Hello";
//sizeof(static_string)是sizeof一个指针，所以在32bit system是4
char stack_string[] = "Hello";
//sizeof(stack_string)是sizeof一个数组，所以是6*sizeof(char)
char*string = new char[6];
strncpy(string,"Hello",6");
//sizeof(string)是sizeof一个指针，所以还是4。
//和第一个不同的是，这个指针指向了动态存储区而不是静态存储区。

不管指针指向的内容在什么地方，sizeof 得到的都是指针的栈大小。

sizof与引用

C++ 中对引用的处理比较特殊。sizeof一个引用得到的结果是sizeof一个被引用的对象的大小。

示例：

struct test {
    int a, b, c, d, e, f, g, h;
};
int main() {
    test &r = new test;
    cout << sizeof(test) << endl; //32
    cout << sizeof r << endl; //也是32
    system("PAUSE");
}

strlen()

返回的是一个字符串的实际长度（字符个数），即从字符串首地址开始，直到遇到第一个'\0'（字符串结束符）为止的这一段长度（不包括'\0'）。

注意数组的初始化问题！！！

示例：

char aa[10];
cout << strlen(aa) << endl; //结果是不定的，因为未初始化，'\0'在内存中的位置不确定
char aa[10] = {'\0'}; 
cout << strlen(aa) << endl; //结果为0
char aa[10] = "jun"; 
cout<<strlen(aa)<<endl; //结果为3

sizeof vs. strlen()

（1）sizeof本质是运算符，strlen是函数。

• sizeof可以用类型做参数，strlen只能用char *做参数，且必须是以'\0'结尾的。

• sizeof还可以用函数做参数，比如：

  short f();
  printf("%d\n", sizeof(f()));
  // 输出的结果是sizeof(short)，即2。

（2）数组做sizeof的参数不退化，传递给strlen就退化为指针了。

char Array[3] = {'0'};
sizeof(Array); // 3
char *p = Array;
strlen(p) == 1; // sizeof(p)结果为4

（3）大部分编译程序在编译的时候就把sizeof计算过了，是类型或是变量的长度，这就是sizeof(x)可以用来定义数组维数的原因。而strlen的结果要在运行的时候才能计算出来，是用来计算字符串的长度的，不是类型占内存的大小。

（4）sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符，不是个函数。

（5）当适用于一个结构体类型或变量时， sizeof返回实际大小；当适用于静态的空间数组时， sizeof返回全部数组的尺寸（占用内存）。

（6）sizeof操作符不能返回动态分配的数组或外部的数组尺寸。

示例：

//sizeof与strlen的区别
char *sz = "abcde";
char sz1[20] = "abcde";
cout << sizeof(sz) << endl;
cout << strlen(sz) << endl;
cout << sizeof(sz1) << endl;
cout << strlen(sz1) << endl;
/*输出:
4
5
20
5
*/

memset与memcpy函数中的使用

关于memset与memcpy函数更详细的信息请见memset，memcpy与strcpy一文。

参数中使用strlen(str)和sizeof(str)有什么区别?

• sizeof(str)返回str这个指针变量所占的内存字节数目;
• strlen(str) 返回str所指向的字符串的长度。
• 用sizeof的话，只给str所指向的内存块连续4个字节清0；
• 用strlen的话，是给str所指向的字符串全部清0；
• sizeof()应该是编译时处理的，而strlen是函数，两者本质不同，使用时注意定义。

示例

char * fun(char *str) {
    memset(str, 0, sizeof(str)); 
        //sizeof(str))求得是指针str的大小，指针占空间是一样的4个字节；
        //str指向的是数组的首地址，这样相当于将数组前四个元素至为‘\0’,
        //用printf("%s")的话，遇到第一个'\0'，即退出。
        //如果用memset(str, 0, strlen(str))；就得看运气了。
        //str指向数组b[400]首地址，b[400]没有显示初始化，
        //strlen是遇到'\0'退出，有可能b[0]就是'\0'，
        //strlen(str)的结果就为0，用printf("%s")就打印不出来了;
        //strlen(str)也有可能是其他值，得看'\0'在b[400]的哪个位置了
    return str;
}
int main(int argc, char* argv[]) {
    char *a, b[400];
    a = fun(b);
}

strlen---------测“字符个数”（包括：不可见字符，如：空格等）

sizeof---------测“BYTE个数”

（整理自网络）

参考资料：

https://baike.baidu.com/item/sizeof/6349467