1. sizeof函数是求表达式或者类型的字节数的，strlen是求字符串的长度的。sizeof遇到’\0’会把它的长度算进去，而strlen不会把’\0’算进去，而是到‘\0’就停止计算。
2. 例如

#include<iostream>
#include<cstring>
#include<string>
using namespace std;

int main()
{
    char str1[]={'h','e','l','l','o','\0','g'};
    int len1=sizeof(str1);

    int len2=strlen(str1);

    cout<<"len1:"<<len1<<"\nlen2:"<<len2<<endl;
    return 0;

}

它的运行结果如下

string的实现在各库中可能有所不同，但是在同一库中相同一点是，无论你的string里放多长的字符串，它的sizeof()都是固定的，字符串所占的空间是从堆中动态分配的，与sizeof()无关。

结论：不要把sizeof当成函数，也不要看作一元操作符，把他当成一个特殊的编译预处理。

在需要求string类型的字符串长度时，只能用.length()或.size()的函数,可返回字符串中字符的个数，不包括结束符‘\0’。

strlen（）函数

在求用字符数组表示的字符串的长度时，可用strlen()函数
strlen(ptr) 的执行机理是：从参数ptr所指向的内存开始向下计数，直到内存中的内容是全0（即’\0’）为止（不会对’\0’进行计数）。用strlen测量字符串的长度，其实就是基于这个原理。

为了验证，我输入了如下程序：

可得到如下结果：

sizeof(name)的执行机理是：

如果name是一个类型名

得到的是该类型的大小（所谓类型的大小，指的是：如果存在一个该类型的变量，这个变量在内存中所占用的字节数），

如果name是一个变量名

那么，sizeof(name)并不会真正访问该变量，而是先获知该变量的类型，然后再返回该类型的大小（即便是struct这样的复杂类型，编译器在编译时也会根据它的各个域记录其大小，所以，由类型得到类型大小，不是一件难事）。换句话说，本质上，sizeof的运算对象是类型。

再看如下的例子：
cout<<sizeof(string*)<<endl; // 4
cout<<sizeof(int*)<<endl; // 4
cout<<sizof(char****)<<endl; // 4
int *d = new int[10];
cout<<sizeof(d)<<endl; // 4

d是我们常说的动态数组，但是他实质上还是一个指针，所以sizeof(d)的值是4。
可以看到，不管是什么类型的指针，大小都是4的，因为指针就是32位的物理地址。

再考虑下面的问题：

double* (*a)[3][6];
cout<<sizeof(a)<<endl; // 4
cout<<sizeof(*a)<<endl; // 72
cout<<sizeof(**a)<<endl; // 24
cout<<sizeof(***a)<<endl; // 4
cout<<sizeof(****a)<<endl; // 8

a是一个很奇怪的定义，他表示一个指向 double*[3][6]类型数组的指针。
既然是指针，所以sizeof(a)就是4。
既然a是执行double*[3][6]类型的指针，*a就表示一个double*[3][6]的多维数组类型，
因此sizeof(*a)=3*6*sizeof(double*)=72。同样的，**a表示一个double*[6]类型
的数组，所以sizeof(**a)=6*sizeof(double*)=24。
***a就表示其中的一个元素，也就是double*了，所以sizeof(***a)=4。
至于****a，就是一个double了，所以sizeof(****a)=sizeof(double)=8。

结论：只要是指针，大小就是4。（64位机上要变成8也不一定）。

数组名作为形参

a.

char str[] = “abc”;
printf("%d %d\n", sizeof(str), strlen(str)); //4 3
这里，是 用数组的形式声明字符串，编译器会自动在字符串后面加上’\0’，所以，数组的元素个数是4而不是3 。对于sizeof(str)而言，sizeof将str视为char [4]l类型的变量，所以，sizeof(str)的结果就是整个数组所占有的空间大小。对于strlen(str)来说，它从str指向的内存开始计数，直到遇到全0的内存（’\0’），所以最后得到结果3。

b.

char str1[10] = “abc”;
printf("%d %d\n", sizeof(str1), strlen(str1)); //10 3

编译器为char str1[10]分配10个数组元素大小的空间，这与初始化它的字符串没有关系，所以sizeof(str1)得到10。

c.

char dog[] = “wangwang\0miao”;
printf("%d %d\n", sizeof(dog), strlen(dog)); //14 8
testchar(dog); //4 8
前两句和a中的情况相同，sizeof(dog)输出整个数组所占的内存大小（包括编译器加上去的’\0’），strlen(dog)遇到’\0’就停止，所以输出8。

再看后面的函数调用，数组名dog作为函数实参传入，我们再来回顾一下testchar函数

void testchar(char str[])
{
printf("%d %d\n", sizeof(str), strlen(str));
}
我们发现，这里sizeof(str)并没有像sizeof(dog)那样得到14，而是得到了4。这是因为，str是函数形参，尽管它是以数组名的形式出现的，传给它的实参也确实是数组名，但sizeof仅仅把它当成一个char*类型的指针看待，所以，sizeof(str)的结果就是char *类型所占的空间4。至于strlen(str)，我们前面说过，它执行的机理就是从str指向的内存开始向下计数，直到遇到’\0’，所以依然得到8。
d.

int arr[10] = { 0 };
printf("%d %d\n", sizeof(arr), sizeof(arr[11])); //40 4
testint(arr); //4
前面说过， 当数组名作为函数形参出现时，sizeof仅仅将其视为一个指针，否则，sizeof认为它代表整个数组，所以，sizeof(arr)得到整个数组所占的字节数40，而testint(arr)的结果是int*类型的指针的长度4。

部分参考博文：https://www.cnblogs.com/zpcdbky/p/5857656.html

#include<stdio.h>
#include<string.h>

main()
{
	char x[]="STRING";
	x[0]=0; x[1]='\0';x[2]='0';
	printf("%d %d\n",sizeof(x),strlen(x));
	
}

#include<stdio.h>
#include <string.h>

int main(void)

{
	char p[]="123067";
	
	printf("%d\n",strlen(p));               //结果为6
	
	p[3]=0;
	
	printf("%d\n",strlen(p));              //结果为3字符串是借助于字符型一维数组来存放的，'\0'ASCLL代码值为0，它作为标志占用存储空间但不记入串的实际长度，
	                                       // 所以用来作为字符串的结束标志 ，所以数字0跟'\0'的效果一样 
	return 0;
}