strlen和sizeof的区别举例,C语言中sizeof和strlen函数区别在哪？
strlen和sizeof的区别举例,C语言中sizeof和strlen函数区别在哪？详细介绍
本文目录一览： C语言中strlen()函数和sizof()函数分别怎么用？区别是什么
1、用法：
strlen(char*
pstr);//求的是字符串的实际长度
sizeof(类型说明符，数组名或表达式)
或sizeof
(
变量名)
比如说有以下数据类型：int
arr[10]
,a;
char
*str="hello
world";
sizeof(arr)/sizeof(a)/sizeof(str)都是可以的，但是只能使用strlen(str),而不能strlen(arr);
2、区别：
2.1
sizeof()是C语言中判断数据类型或者表达式长度符；不是一个函数，字节数的计算在程序编译时进行，而不是在程序执行的过程中才计算出来。
2.2
strlen()求得方法是从开始到遇到第一个'\0'，如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。
总结的说来sizeof的适用范围更广，但是在返回实际的字符数组中的数据是，strlen()更方便，因为它返回的是实际的字符串长度，而sizeof是返回数组大小。
c语言sizeof和strlen的区别
char name[]="nike" ;
sizeof(name)=5
如果数组定义成int，就不能用scanf("%s",name);来输入字符串了，因为这两个类型是不同的。%s只能输入char字符串数据
sizeof运算符计算的是操作数类型的大小，只是数组会乘以长度而已，和传入的具体内容无关。
要强行输出5的话那就sizeof("nike")吧……
要强行可以计算补了0长度的那就strlen+1
\0 只在char型数组中才有。
区别如下：
1、指代上的区别
（1）sizeof：用来获取字符串长度的导引，是处理字符串的重要工具。
（2）strlen：做的是一个计数器。
2、用法上的区别
（1）sizeof：sizeof( type_name ); // sizeof（type）; 在编译时有效，而不是在运行时有效。
（2）strlen：extern unsigned int strlen(char *s); 返回s的长度，不包含终止符NULL。
定义
sizeof是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type(including aggregate types). This keyword returns a value of type size_t。
sizeof与strlen的区别
首先说明一点，char类型占一个字节，所以sizeof(char)是1，这点要理解
str1是一个指针，只是指向了字符串"absde"而已。所以sizeof(str1)不是字符串占的空间也不是字符数组占的空间，而是一个字符型指针占的空间。所以sizeof(str1)=sizeof(char*)=4，在C/C++中一个指针占4个字节
str2是一个字符型数组。C/C++规定，对于一个数组，返回这个数组占的总空间，所以sizeof(str2)取得的是字符串"absde"占的总空间。"absde"中，共有a b s d e \0六个字符，所以str2数组的长度是6，所以sizeof(str2)=6*sizeof(char)=6
str3已经定义成了长度是8的数组，所以sizeof(str3)为8
str4和str2类似，'0' '1' ... '9'加上'\0'共11个字符，所以ss占的空间是8
总之，对于指针，sizeof操作符返回这个指针占的空间，一般是4个字节；而对于一个数组，sizeof返回这个数组所有元素占的总空间。char*与char[]容易混淆，一定要分清，而且char*="aaa"的写法现在不被提倡，应予以避免
而strlen不区分是数组还是指针，就读到\0为止返回长度。而且strlen是不把\0计入字符串的长度的。
strlen:是C标准库中的字符串函数，用于统计字符的个数。
sizeof:是c语言中的运算符，确切的说是一个编译时运算符，用于统计类型或者变量所占的内存字节数。示例，以32位系统为例。
char *str = "hello";strlen(str); //它的值是5，因为hello这个字符串有5个字符sizeof(str); //它的值是4，因为char *是一个指针类型，它占4个字节。sizeof("hello"); //它的值是5，是因为hello有5个字符，每一个字符占1个字节。int a[2] = {0};sizeof(a); //它的值是8，因为a中有2个int型变量，每个int型占4个字节，所以8字节
sizeof(str)，其中str为字符串的头指针，指针占的空间为4字节，即为4
strlen(str)，计算str的有效长度，hello长度为5，输出为5；
sizeof(s)，s是一个字符串，此时，sizeof计算的是这个字符串的长度，除了hello占5个字节以外，还有一个字节的'\0'表示字符串结束，总共为6；
希望楼主能明白
sizeof和strlen没有任何相似的地方。
strlen计算的是字符串长度的函数，直到遇到'\0'结束，结果不包括'\0'在内。
sizeof是一个运算符，在编译的时候就计算结果了，可以确定一个变量、类型、数组占用的内存空间。
sizeof（）求的是字节数，不同类型的数据在内存中的字节数是不一样的，对于字符串来说，也就是字符的个数，因为一个字符占1个字节的内存，当然这里包括字符串最后的'\0'字符。
而strlen（）求的是字符串的长度，也就是字符的个数，不包括最后的'\0'字符
1. strlen 是函数，sizeof 是运算符。
2. strlen 测量的是字符的实际长度，以'\0' 结束。而sizeof 测量的是字符的分配大小。
比如：
char str[20] = "hello";
printf("strlen: %d\n", strlen(str));
printf("sizeof: %d\n", sizeof(str));
结果显示为：
strlen: 5
sizeof: 20
3.但是在子函数中，size of 会把从主函数中传进来的字符数组当作是指针来处理。指针的大小又是由机器来决定，而不是人为的来决定的。
#include
void size_of(char str[])
{
printf("sizeof:%d\n", sizeof(str));
}
int main()
{
char str[20] = "hello";
size_of(str);
return 0;
}
结果显示为sizeof：4
4.我们知道字符数组的初始化一次性赋值，也可以逐个赋值。可以指定数组的大小，也可以不指定数组长度。
#include
#include
int main()
{
char str1[] = "hello";
char str2[] = {'h', 'e', 'l', 'l', 'o', '\0'};
char str3[] = {'h', 'e', 'l', 'l', 'o'};
printf("str1:%s\n",str1);
printf("str2:%s\n",str2);
printf("str3:%s\n",str3);
printf("str1:%d\n", strlen(str1));
printf("str2:%d\n", strlen(str2));
printf("str3:%d\n", strlen(str3));
return 0;
}
结果显示为：
str1:hello
str2:hello
str3:hellohello
str1:5
str2:5
str3:10
5.strlen的结果要在运行的时候才能计算出来，是用来计算字符串的长度，不是类型占内存的大小。而大部分编译程序在编译的时候就把sizeof计算过了是类型或是变量的长度。
6.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
扩展资料：
sizeof(...)是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。
由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。实际上，用sizeof来返回类型以及静态分配的对象、结构或数组所占的空间，返回值跟对象、结构、数组所存储的内容没有关系。
strlen(...)是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。
它的功能是：返回字符串的长度。该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。
参考资料：百度百科——sizeof
C语言中sizeof与strlen的区别是什么
区别如下：
1、指代上的区别
（1）sizeof：用来获取字符串长度的导引，是处理字符串的重要工具。
（2）strlen：做的是一个计数器。
2、用法上的区别
（1）sizeof：sizeof( type_name ); // sizeof（type）; 在编译时有效，而不是在运行时有效。
（2）strlen：extern unsigned int strlen(char *s); 返回s的长度，不包含终止符NULL。
3、规则上的区别
（1）sizeof：可用于任何变量名，类型名或常量值。 当用于变量名（不是数组名）或常量时，不需要括号。
（2）strlen：从内存的某个特定位置开始扫描（可以是字符串的开头，中间的某个位置，甚至是不确定的存储区域），直到第一个字符串结束字符'\ 0'为止 ，然后返回计数器值。
strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。
char aa[10];cout<
<strlen(aa)<<endl; 结果是不定的
char aa[10]={'\0'}; cout<
<strlen(aa)<<endl; 结果为0
char aa[10]="jun"; cout<
<strlen(aa)<<endl; 结果为3
而sizeof()函数返回的是变量声明后所占的内存数，不是实际长度。
sizeof(aa) 返回10
int a[10]; sizeof(a) 返回40
1.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
2.sizeof是算符，strlen是函数。
3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
sizeof还可以用函数做参数，比如：
short f();
printf("%d\n", sizeof(f()));
输出的结果是sizeof(short)，即2。
4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。
5.大部分编译程序 在编译的时候就把sizeof计算过了是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;
6.strlen的结果要在运行的时候才能计算出来，是用来计算字符串的长度，不是类型占内存的大小。
7.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
8.当适用于一个结构类型时或变量， sizeof 返回实际的大小，当适用于静态的空间数组， sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回被动态分派的数组或外部数组的尺寸
9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，
如：
fun(char [8])
fun(char [])
都等价于 fun(char *)
在C++里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小
如果想在函数内知道数组的大小， 需要这样做：
进入函数后用memcpy拷贝出来，长度由另一个形参传进去
fun(unsiged char *p1, int len)
{
unsigned char* buf = new unsigned char[len+1]
memcpy(buf, p1, len);
}
我们经常使用 sizeof 和 strlen 的场合，通常是计算字符串数组的长度
看了上面的详细解释，发现两者的使用还是有区别的，从这个例子可以看得很清楚：
char str[20]="0123456789";
int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度，以结束符 0x00 为字符串结束。
int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的数组 str[20] 所占的内存空间的大小，不受里面存储的内容改变。
上面是对静态数组处理的结果，如果是对指针，结果就不一样了
char* ss = "0123456789";
sizeof(ss) 结果 4 ===》ss是指向字符串常量的字符指针，sizeof 获得的是一个指针的之所占的空间,应该是
长整型的，所以是4
sizeof(*ss) 结果 1 ===》*ss是第一个字符 其实就是获得了字符串的第一位'0' 所占的内存空间，是char类
型的，占了 1 位
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度，则一定要使用 strlen
sizeof返回对象所占用的字节大小. //正确
strlen返回字符个数. //正确
在使用sizeof时，有一个很特别的情况，就是数组名到指针蜕变，
char Array[3] = {'0'};
sizeof(Array) == 3;
char *p = Array;
strlen(p) == 1;//sizeof(p)结果为4
在传递一个数组名到一个函数中时，它会完全退化为一个指针
----------------------------------------------------------
看完以上你是否很清楚sizeof和strlen的区别了呢？还不明白的话，我们看下面几个例子：
第一个例子
char* ss = "0123456789";
sizeof(ss) 结果 4 ===》ss是指向字符串常量的字符指针
sizeof(*ss) 结果 1 ===》*ss是第一个字符
大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度
这就是sizeof(x)可以用来定义数组维数的原因
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;
大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度
这就是sizeof(x)可以用来定义数组维数的原因
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;
char ss[] = "0123456789";
sizeof(ss) 结果 11 ===》ss是数组，计算到\0位置，因此是10+1
sizeof(*ss) 结果 1 ===》*ss是第一个字符
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'结尾的
char q[]="abc";
char p[]="a\n";
sizeof(q),sizeof(p),strlen(q),strlen(p);
结果是 4 3 3 2
第三个例子
char szPath[MAX_PATH]
如果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，但是将szPath作为虚参声明时（void fun(char szPath[MAX_PATH])）,sizeof(szPath)却会是4(指针大小)
子
char szPath[MAX_PATH]
如果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，但是将szPath作为虚参声明时（void fun(char szPath[MAX_PATH])）,sizeof(szPath)却会是4(指针大小)
还有一位网友的说明也很好：
其实理解 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 得到的都是指针的栈大小
C++ 中对引用的处理比较特殊；sizeof 一个引用得到的结果是 sizeof 一个被引用的对象的大小；所以
struct O
{
int a, b, c, d, e, f, g, h;
};
int main()
{
O & r = *new O;
cout << sizeof(O) << endl; // 32
cout << sizeof r << endl; // 也是 32
system("PAUSE");
}
r 引用的是整个的 O 对象而不是指向 O 的指针，所以 sizeof r 的结果和 sizeof O 完全相同。
sizeof获得是所占的字节数，所分配的空间的字节数。
strlen获得是长度（实际字符的个数）。
例如： char a[5]="abc";
sizeof(a) 等于5，因为分配了5个字节的空间。
而strlen(a)等于3，这是其实际字符的个数
sizeof 是被测试类型占用字节的大小
strlen是以\0为结束符的字符串的串长度(不含结束符)
比如吧:
char *p = "0123456789abcdef";
char str[] = "0123456789abcdef";
char str2[100] = "0123456789abcdef";
sizeof(p) 只是 4(或8与操作系统有关,32位系统应当只是4)
strlen(p) 是16个长度
sizeof(str) 是17
strlen(str) 是16
sizeof(str2) 是100
strlen(str2) 是16
一、指代不同
1、sizeof：用于获取字符串的长度，是处理字符串的重要工具。
2、strlen：所作的是一个计数器的工作。
二、规则不同
1、sizeof：可用于任何变量名、类型名或常量值，当用于变量名（不是数组名）或常量时，不需要用圆括号。
2、strlen：从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符'\0'为止，然后返回计数器值。
三、用法不同
1、sizeof：sizeof( type_name ); // sizeof( 类型 )；编译时起作用，而不是运行时。
2、strlen：extern unsigned int strlen(char *s)；返回s的长度，不包括结束符NULL。
参考资料来源：百度百科-sizeof()
参考资料来源：百度百科-strlen
</strlen(aa)<
</strlen(aa)<
</strlen(aa)<
sizeof和strlen在c语言的区别是什么？
sizeof和strlen在c语言的区别是：用法不同。
sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。sizeof是算符，strlen是函数。sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以“＼0”结尾的。
strlen的结果要在运行的时候才能计算出来，时用来计算字符串的长度，不是类型占内存的大小。sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
函数调用：
sizeof(函数名（))
sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用，举例来说定义如下函数：
int myprint ()
{undefined
printf(“hello\n”)；
return 0;
｝
int main()
{undefined
printf(“％d”，sizeof(mypaint()));
return 0;
｝
结果只打印函数返回类型的sizeof值，并没有打印hello说明函数myprint并没有调用。
strlen和sizeof有什么区别？
Sizeof与Strlen的区别与联系(转）
1.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
2.sizeof是算符，strlen是函数。
3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
sizeof还可以用函数做参数，比如：
short f();
printf("%d\n", sizeof(f()));
输出的结果是sizeof(short)，即2。
4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。
5.大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;
6.strlen的结果要在运行的时候才能计算出来，时用来计算字符串的长度，不是类型占内存的大小。
7.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
8.当适用了于一个结构类型时或变量， sizeof 返回实际的大小，
当适用一静态地空间数组， sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸
9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，
如：
fun(char [8])
fun(char [])
都等价于 fun(char *)
在C++里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小
如果想在函数内知道数组的大小， 需要这样做：
进入函数后用memcpy拷贝出来，长度由另一个形参传进去
fun(unsiged char *p1, int len)
{
unsigned char* buf = new unsigned char[len+1]
memcpy(buf, p1, len);
}
我们能常在用到 sizeof 和 strlen 的时候，通常是计算字符串数组的长度
看了上面的详细解释，发现两者的使用还是有区别的，从这个例子可以看得很清楚：
char str[20]="0123456789";
int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度，以结束符 0x00 为字符串结束。
int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的数组 str[20] 所占的内存空间的大小，不受里面存储的内容改变。
上面是对静态数组处理的结果，如果是对指针，结果就不一样了
char* ss = "0123456789";
sizeof(ss) 结果 4 ＝＝＝》ss是指向字符串常量的字符指针，sizeof 获得的是一个指针的之所占的空间,应该是
长整型的，所以是4
sizeof(*ss) 结果 1 ＝＝＝》*ss是第一个字符 其实就是获得了字符串的第一位'0' 所占的内存空间，是char类
型的，占了 1 位
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度，则一定要使用 strlen
strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。
charaa[10];cout<
<strlen(aa)<<endl; 结果是不定的
charaa[10]={'\0'};cout<
<strlen(aa)<<endl; 结果为0
charaa[10]="jun";cout<
<strlen(aa)<<endl; 结果为3
而sizeof()函数返回的是变量声明后所占的内存数，不是实际长度。
sizeof(aa)返回10
inta[10];sizeof(a)返回40
1.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
2.sizeof是算符，strlen是函数。
3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
sizeof还可以用函数做参数，比如：
shortf();
printf("%d\n",sizeof(f()));
输出的结果是sizeof(short)，即2。
4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。
5.大部分编译程序在编译的时候就把sizeof计算过了是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因
charstr[20]="0123456789";
inta=strlen(str);//a=10;
intb=sizeof(str);//而b=20;
6.strlen的结果要在运行的时候才能计算出来，是用来计算字符串的长度，不是类型占内存的大小。
7.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
8.当适用于一个结构类型时或变量，sizeof返回实际的大小，当适用于静态的空间数组，sizeof归还全部数组的尺寸。
sizeof操作符不能返回被动态分派的数组或外部数组的尺寸
9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，
如：
fun(char[8])
fun(char[])
都等价于fun(char*)
在C++里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小
如果想在函数内知道数组的大小，需要这样做：
进入函数后用memcpy拷贝出来，长度由另一个形参传进去
fun(unsigedchar*p1,intlen)
{
unsignedchar*buf=newunsignedchar[len+1]
memcpy(buf,p1,len);
}
我们经常使用sizeof和strlen的场合，通常是计算字符串数组的长度
看了上面的详细解释，发现两者的使用还是有区别的，从这个例子可以看得很清楚：
charstr[20]="0123456789";
inta=strlen(str);//a=10;>>>>strlen计算字符串的长度，以结束符0x00为字符串结束。
intb=sizeof(str);//而b=20;>>>>sizeof计算的则是分配的数组str[20]所占的内存空间的大小，不受里面存储的内容改变。
上面是对静态数组处理的结果，如果是对指针，结果就不一样了
char*ss="0123456789";
sizeof(ss)结果4===》ss是指向字符串常量的字符指针，sizeof获得的是一个指针的之所占的空间,应该是
长整型的，所以是4
sizeof(*ss)结果1===》*ss是第一个字符其实就是获得了字符串的第一位'0'所占的内存空间，是char类
型的，占了1位
strlen(ss)=10>>>>如果要获得这个字符串的长度，则一定要使用strlen
sizeof返回对象所占用的字节大小.//正确
strlen返回字符个数.//正确
在使用sizeof时，有一个很特别的情况，就是数组名到指针蜕变，
charArray[3]={'0'};
sizeof(Array)==3;
char*p=Array;
strlen(p)==1;//sizeof(p)结果为4
在传递一个数组名到一个函数中时，它会完全退化为一个指针
----------------------------------------------------------
看完以上你是否很清楚sizeof和strlen的区别了呢？还不明白的话，我们看下面几个例子：
第一个例子
char*ss="0123456789";
sizeof(ss)结果4===》ss是指向字符串常量的字符指针
sizeof(*ss)结果1===》*ss是第一个字符
大部分编译程序在编译的时候就把sizeof计算过了是类型或是变量的长度
这就是sizeof(x)可以用来定义数组维数的原因
charstr[20]="0123456789";
inta=strlen(str);//a=10;
intb=sizeof(str);//而b=20;
大部分编译程序在编译的时候就把sizeof计算过了是类型或是变量的长度
这就是sizeof(x)可以用来定义数组维数的原因
charstr[20]="0123456789";
inta=strlen(str);//a=10;
intb=sizeof(str);//而b=20;
charss[]="0123456789";
sizeof(ss)结果11===》ss是数组，计算到\0位置，因此是10+1
sizeof(*ss)结果1===》*ss是第一个字符
charss[100]="0123456789";
sizeof(ss)结果是100===》ss表示在内存中的大小100×1
strlen(ss)结果是10===》strlen是个函数内部实现是用一个循环计算到\0为止之前
intss[100]="0123456789";
sizeof(ss)结果400===》ss表示在内存中的大小100×4
strlen(ss)错误===》strlen的参数只能是char*且必须是以'\0'结尾的
charq[]="abc";
charp[]="a\n";
sizeof(q),sizeof(p),strlen(q),strlen(p);
结果是4332
第三个例子
charszPath[MAX_PATH]
如果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，但是将szPath作为虚参声明时（voidfun(charszPath[MAX_PATH])）,sizeof(szPath)却会是4(指针大小)
子
charszPath[MAX_PATH]
如果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，但是将szPath作为虚参声明时（voidfun(charszPath[MAX_PATH])）,sizeof(szPath)却会是4(指针大小)
还有一位网友的说明也很好：
其实理解sizeof只需要抓住一个要点：栈
程序存储分布有三个区域：栈、静态和动态。能够从代码直接操作的对象，包括任何类型的变量、指针，都是在栈上的；动态和静态存储区是靠栈上的所有指针间接操作的。sizeof操作符，计算的是对象在栈上的投影体积；记住这个就很多东西都很清楚了。
charconst*static_string="Hello";
sizeof(static_string)是sizeof一个指针，所以在32bitsystem是4
charstack_string[]="Hello";
sizeof(stack_string)是sizeof一个数组，所以是6*sizeof(char)
char*string=newchar[6];
strncpy(string,"Hello",6");
sizeof(string)是sizeof一个指针，所以还是4。和第一个不同的是，这个指针指向了动态存储区而不是静态存储区。
不管指针指向的内容在什么地方，sizeof得到的都是指针的栈大小
C++中对引用的处理比较特殊；sizeof一个引用得到的结果是sizeof一个被引用的对象的大小；所以
structO
{
inta,b,c,d,e,f,g,h;
};
intmain()
{
O&r=*newO;
cout<
<sizeof(o)<<endl; 32
cout<
<sizeofr<<endl; 也是32
system("PAUSE");
}
r引用的是整个的O对象而不是指向O的指针，所以sizeofr的结果和sizeofO完全相同。
strlen用来求字符串的长度用的
而sizeof是用来求指定变量或者变量类型等所占内存大小用的
比如strlen（"nihao"）它的结果是5
而sizeof(int)它的结果是2也就是说int型占两个字节
sizeof与strlen的区别：
一、sizeof
sizeof(...)是运算符，在头文件中typedef为unsignedint，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。
它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。
由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。实际上，用sizeof来返回类型以及静态分配的对象、结构或数组所占的空间，返回值跟对象、结构、数组所存储的内容没有关系。
具体而言，当参数分别如下时，sizeof返回的值表示的含义如下：
数组——编译时分配的数组空间大小；
指针——存储该指针所用的空间大小（存储该指针的地址的长度，是长整型，应该为4）；
类型——该类型所占的空间大小；
对象——对象的实际占用空间大小；
函数——函数的返回类型所占的空间大小。函数的返回类型不能是void。
二、strlen
strlen(...)是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。
它的功能是：返回字符串的长度。该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。
sizeof获得是所占的字节数，所分配的空间的字节数。
strlen获得是长度（实际字符的个数）。
例如：
char
a[5]="abc";
sizeof(a)
等于5，因为分配了5个字节的空间。
而strlen(a)等于3，这是其实际字符的个数
区别：
一、定义不同
sizeof是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。
2、它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。具体而言，当参数分别如下时，sizeof返回的值表示的含义如下：数组——编译时分配的数组空间大小；指针——存储该指针所用的空间大小（存储该指针的地址的长度，是长整型，应该为4）。
二、语法不同
1、strlen是函数，要在运行时才能计算。参数必须是字符型指针。当数组名作为参数传入时，实际上数组就退化成指针了。
2、它的功能是：返回字符串的长度。该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。
扩展资料
1、sizeof是算符，strlen是函数。 数组做sizeof的参数不退化，传递给strlen就退化为指针了。strlen所作的仅仅是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符'\0'为止，然后返回计数器值(长度不包含'\0')。
2、sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。
参考资料：百度百科：strlen；百度百科：sizeof
</sizeofr<
</sizeof(o)<
</strlen(aa)<
</strlen(aa)<
</strlen(aa)<
sizeof和strlen区别
sizeof和strlen的区别是：含义不同、功能不同。
1、含义不同
在定义时，要知道到strlen是一个函数，它用来计算指定字符串str的长度，但不包括结束字符（即null字符）。而sizeof是一个单目运算符，而不是一个函数，它的参数可以是数组、指针、类型、对象、函数等。这就是strlen和sizeof的最本质区别。
2、功能不同
sizeof的功能能比较简单，主要是：获得保证，能容纳实现所建立的最大对象的字节大小。而strlen的功能就比较多和繁琐了，是返回字符串的长度，这个字符串可能是自己定义的，也可能是内存中随机的，这个函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL，返回的长度大小不包括NULL。
strlen的用法特点
strlen=string length，顾名思义，该函数是用来求解字符串的长度的，所以我们也应该探讨一下字符串的概念；我们都知道在编译器中输入printf（“Hello World！”），就会输出“Hello World！”，这就是一个字符串，类似这种由双引号引起来的一串字符称为字符串面值，或者简称字符串。
接着我们就需要了解一下“＼0”这个转义字符了，记住任何一个字符串的结尾都会隐藏一个“＼0”，他是字符串的结束标志，所以我们在用strlen函数读取字符串的时候，当我们遇到“＼0”时我们就要停止读取，此时“＼0”前字符的个数就是字符串的长度，注意：这里的“＼0"只是结束标志，仅仅告诉我们strlen函数读取到这里就要停止了，“＼0”不算做一个字符！
以上内容参考百度百科-sizeof百度百科-strlen
C语言中sizeof和strlen函数区别在哪？
1、用法不一样
sizeof可以用类型做参数。
strlen只能用char*做参数，且必须是以''\0''结尾的。sizeof还可以用函数做参数，比如：
short f();
printf("%d\n", sizeof(f()));
输出的结果是sizeof(short)，即2。
2、功能不一样
sizeof的功能能是，获得保证，能容纳实现所建立的最大对象的字节大小。
strlen的功能是返回字符串的长度，该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。
3、意思不一样
sizeof(...)是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。
strlen(...)是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。
通俗一点，简单明了一点来讲，二者都可以用来取字符串长度，不同之处在于sizeof取到的字符串长度包括字符串结束标记‘\0’，而strlen得到的长度则不包括‘\0’，而‘\0’在字符串中是不显示的，所以sizeof得到的字符串长度要比strlen得到的字符串长度大1。
纯手打，希望对你有帮助……
什么啊，那最佳答案怎么得来的啊？
那个什么最佳答案的不要误导了LZ才好，
strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0',而sizeof()函数返回的是变量声明后所占的内存数，不是实际长度，我若通过赋值方法给字符串中某一字符赋值为\0，它的strlen（）值变化很大，而sizeof()不变，根本不总是长度大一的关系！！！
sizeof在编译器求解，strlen在运行期求解，这是主要区别
其次strlen只能求C风格字符串长度sizeof()可以求很多类型的大小
strlen只能求字符串的长度
而sizeof适用范围就广的多 所有的变量都能求 结构什么的。另外，一些看不见的，诸如\0也会计算在内
1、操作
strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。
而sizeof()返回的是变量声明后所占的内存数，不是实际长度。
2、参数类型
sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
3、类型
sizeof是操作符（关键字），strlen是函数。
扩展资料
strlen函数原型：
size_t strlen(const char *string)
size_t 是无符号整数的别名，在vs2008编译器中可以查看其宏定义。
功能：
其功能是获取字符串的长度。
返回值：
在MSDN文档中查看strlen函数的返回值，叙述如下。
Each of these functions returns the number of characters in string, excluding the terminal NULL. No return value is reserved to indicate an error.
每个函数都返回字符串中的字符数，不包括终端NULL。不保留返回值以指示错误。
参数：
Null-terminated string
空终止字符串， 字符串标准库提供的头文件中包含操作以空字符结尾的字符串(null-terminated string)的函数。
参考资料：百度百科——strlen
sizeof（x），strlen（x）请问这两个是什么意思？
后者返回值是字符串X的字符串长度（不包含终止符
\0）
前者.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned
int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
sizeof是算符，strlen是函数。
这个sizeof(x
)是求括号中的变量或值所点的字节数，
而这个strlen(x)是求这个X（这个可以是一个字符串）的长度，
不包括“/0”
sizeof(str)，其中str为字符串的头指针，指针占的空间为4字节，即为4
strlen(str)，计算str的有效长度，hello长度为5，输出为5；
sizeof(s)，s
是一个字符串，此时，sizeof
计算的是这个字符串的长度，除了hello占5个字节以外，还有一个字节的'\0'表示字符串结束，总共为6；
希望楼主能明白