sizeof 和 strlen 的区别

一、sizeof

sizeof 是C语言中用来计算变量所占内存空间大小的一个操作符，单位是字节，如果操作数是类型，那么计算的就是该类型创建的变量的内存空间大小。
返回这个空间大小，类型为size_t。
size_t类型的数据一般使用占位符%zd输出打印

int main()
{int a = 10;printf("%zd\n", sizeof(a));printf("%zd\n", sizeof(int));return 0;
}

结果：

如果sizeof 的操作数是变量，括号可以省略不写

int a = 10;
printf("%zd\n", sizeof a);

所以sizeof只会在乎操作数的类型的空间大小，不在乎操作数变量中所存放的数据。

值得注意的是：
如果sizeof括号中的是一个表达式，表达式并不会进行计算

int main()
{int a = 8;int b = 6;int c = 0;int sz = sizeof(c = a + b);printf("%zd\n", c);printf("%zd\n", sz);return 0;
}

结果：表达式c = a + b并不会计算，c的值还是0：

如果sizeof括号中的表达式中的存在不一样的类型，那么sizeof计算的值最终表达式的结果的类型（表达式不会真实参与计算）

int main()
{int a = 8;long b = 6;short c = 0;int sz = sizeof(c = a + b);printf("%zd\n", c);printf("%zd\n", sz);return 0;
}

结果：表达式是c = a + b，所以表达式的最终结果是c，类型是short，所以计算的空间大小是short类型变量的大小 2（但是表达式c = a + b并不会真实计算，所以c的值还是0）

二、strlen

strlen是C语言中的一个库函数，作用是计算字符串的长度。
函数原型：

size_t strlen ( const char * str );

• str 指向需要计算长度的字符串的
• 函数计算返回字符串的长度，类型是size_t
• 使用strlen库函数需要包含头文件#include <string.h>

注意：

1. strlen统计的是从给定的str指针（地址）开始，'\0'之前的字符串中的字符个数（不包括'\0'）

#include <stdio.h>
#include <string.h>int main()
{char str[] = "hello world";size_t sz = strlen(str);printf("%zd\n", sz);return 0;
}

结果：hello 和 world分别是5个字符，空格也是字符，遇到字符串末尾的’\0’结束。所以结果是11个

2. sizeof计算的是变量所占空间的大小，不在乎变量中所存的数据，当计算的是字符串的大小的时候，‘\0’会被认为是一个字符占用一个字节。所以 sizeof计算字符串的大小，’\0’也会被计算在内。

int main()
{char arr[] = { 'h', 'e', 'l', 'l', 'o' };char str[] = "hello";printf("%zd\n", sizeof(arr));//5printf("%zd\n", sizeof(str));//6return 0;
}

注意：
字符串的后面默认都会有个'\0'，来标志着字符串的结束；
一个字符一个字符存放的字符数组后面并不会默认有'\0'。

#include <stdio.h>
#include <string.h>int main()
{char arr[] = { 'h', 'e', 'l', 'l', 'o' };char str[] = "hello";printf("%zd\n", strlen(arr));printf("%zd\n", strlen(str));return 0;
}

strlen(str)计算的结果是正确的；
因为strlen函数遇到'\0'才停止，而字符数组arr本身没有’\0’，所以strlen就会一直向后面寻找计算，不仅可能会越界，而且在内存中数组arr的后面不知道什么时候会遇到’\0’，所以strlen(arr)计算的结果是不确定的。

三、sizeof 和 strlen 的对比

sizeof	strlen
sizeof是操作符，不需要包含头文件	strlen是库函数，需要包含头文件
sizeof计算操作数内存空间的大小，单位是字节	strlen计算字符串的长度，统计’\0’之前的字符个数
sizeof不关注操作数内存中存放的数据	strlen关注内存中是否有’\0’，如果没有’\0’，就会继续向后寻找，可能会越界
sizeof中如果存在表达式，表达式不会进行计算的

四、练习

在练习之前，我们来复习一下数组名的意义：
数组名代表数组首元素的地址，但是有两个例外：
1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小；
2.&数组名，这里的数组名表示整个数组，表示取出整个数组的地址。

如果是二维数组的数组名，二维数组的首元素是第一行的一维数组，所以二维数组的数组名表示第一行一维数组的地址。（两个例外情况除外）

4.1 一维数组

#include <stdio.h>
int main()
{int a[] = { 1,2,3,4 };printf("%zd\n", sizeof(a));//16printf("%zd\n", sizeof(a + 0));//4printf("%zd\n", sizeof(*a));//4printf("%zd\n", sizeof(a + 1));//4printf("%zd\n", sizeof(a[1]));//4printf("%zd\n", sizeof(&a));//4printf("%zd\n", sizeof(*&a));//16printf("%zd\n", sizeof(&a + 1));//4printf("%zd\n", sizeof(&a[0]));//4printf("%zd\n", sizeof(&a[0] + 1));//4return 0;
}

以下是在x86环境下的结果

1. a是数组名，sizeof(a)表示计算整个数组的大小 ，是16个字节；
2. a并没有单独放在sizeof中，所以代表数组首元素的地址，+0相当于没变，还是数组首元素的地址，地址就是4个字节；
3. a是数组首元素的地址，*a解引用得到数组的首元素，类型是int，大小是4个字节；
4. a是数组首元素的地址，+1跳过一个int类型数据的大小，但还是一个地址，就是4个字节；
5. a[1]就是数组第二个元素，类型是int，大小是4个字节；
6. &a表示取出的是整个数组的地址，地址是4个字节；
7. &a表示取出的是整个数组的地址，然后*&a解引用得到整个数组，相当于sizeof(a)，计算的是整个数组的大小，是16个字节；
8. &a表示取出的是整个数组的地址，+1跳过整个数组，是数组后面位置的地址，地址是4个字节；
9. a[0]是数组第一个元素，&a[0]是数组第一个元素的地址，地址是4个字节。
10. 数组第一个元素的地址+1，跳过一个int类型元素的，表示第二个元素的地址，地址是4个字节。

4.2 二维数组

int main()
{int a[3][4] = { 0 };printf("%zd\n", sizeof(a));//48printf("%zd\n", sizeof(a[0][0]));//4printf("%zd\n", sizeof(a[0]));//16printf("%zd\n", sizeof(a[0] + 1));//4printf("%zd\n", sizeof(*(a[0] + 1)));//4printf("%zd\n", sizeof(a + 1));//4printf("%zd\n", sizeof(*(a + 1)));//16printf("%zd\n", sizeof(&a[0] + 1));//4printf("%zd\n", sizeof(*(&a[0] + 1)));//16printf("%zd\n", sizeof(*a));//16printf("%zd\n", sizeof(a[3]));//16return 0;
}

以下是在x86环境下的结果（x64环境下，地址是8个字节）

1. a是数组名，sizeof(a)表示计算整个数组的大小 ，是48个字节；
2. a[0][0]就是二维数组第一行的第一个元素，类型是int，大小是4个字节；
3. a[0]是二维数组的首元素，就是第一行的一维数组，sizeof(a[0])就是计算第一行数组a[0]的大小，是16个字节。
4. a[0]可以表示二维数组第一行的数组的数组名，代表第一行数组的首元素，+1跳过一个int类型大小的元素，表示第一行第二个元素的地址，地址是4个字节；
5. *(a[0] + 1))就是拿到第一行第二个元素，类型是int，大小是4个字节；
6. a是二维数组数组名，代表数组名首元素的地址，也就是第一行的一维数组的地址，+1跳过一个int[4]类型的一维数组，表示第二行的一维数组的地址，地址是4个字节；
7. *(a + 1)表示第二行一维数组的数组名，sizeof( *(a + 1) )就是计算第二行一维数组的大小，是16个字节；
8. &a[0]就是第一行数组的地址，+1 跳过该数组，表示第二行数组的地址，相当于a+1，地址是4个字节；
9. a是数组名表示数组首元素的地址，就是第一行数组的地址，*解引用得到第一行数组，sizeof(*a)计算的是第一行数组的大小，是16个字节；
10. a[3]很明显是越界了，但是并没有对其进行操作，只是计算空间大小，虽然二维数组中没有定义a[3]，但是还是会按照前面的数组大小来进行计算，大小是16个字节。

4.3 字符数组

代码一：

int main()
{char arr[] = { 'a','b','c','d','e','f' };printf("%d\n", sizeof(arr));//6printf("%d\n", sizeof(arr + 0));//4printf("%d\n", sizeof(*arr));//1printf("%d\n", sizeof(arr[1]));//1printf("%d\n", sizeof(&arr));//4printf("%d\n", sizeof(&arr + 1));//4printf("%d\n", sizeof(&arr[0] + 1));//4return 0;
}

以下是在x86环境下的结果

1. arr是数组名，sizeof(arr)计算的是整个数组的大小，是6个字节；
2. arr是数组名，没有单独放到sizeof中，那就还是表示数组首元素的地址，+0相当于没变，还是数组首元素的地址，地址就是4个字节；
3. *arr就是数组的首元素，类型是char，大小是1个字节；
4. arr[1]是数组第二个元素，类型是char，大小是1个字节；
5. &arr是取出整个数组的地址，地址是4个字节；
6. &arr + 1是跳过该数组，是数组后面的位置的地址，地址是4个字节；
7. &arr[0]是数组首元素的地址，+1就是跳过一个char类型的大小，就是跳过一个字节，表示第二个元素的地址，相当于a + 1，地址是4个字节。

代码二：

#include <string.h>int main()
{char arr[] = { 'a','b','c','d','e','f' };printf("%zd\n", strlen(arr));printf("%zd\n", strlen(arr + 0));printf("%zd\n", strlen(*arr));printf("%zd\n", strlen(arr[1]));printf("%zd\n", strlen(&arr));printf("%zd\n", strlen(&arr + 1));printf("%zd\n", strlen(&arr[0] + 1));return 0;
}

这种的字符数组arr并不是以’\0’结尾，而strlen计算字符串的结束标志是’\0’，所以这种写法是不建议的，结果是未知的，因为不知道什么时候会遇到’\0’。

代码三：

int main()
{char arr[] = "abcdef";printf("%d\n", sizeof(arr));//7printf("%d\n", sizeof(arr + 0));//4printf("%d\n", sizeof(*arr));//1printf("%d\n", sizeof(arr[1]));//1printf("%d\n", sizeof(&arr));//4printf("%d\n", sizeof(&arr + 1));//4printf("%d\n", sizeof(&arr[0] + 1));//4return 0;
}

以下是在x86环境下的结果

1. arr是数组名，sizeof(arr)计算的是整个数组的大小，是7个字节；
2. arr是数组名，但是没有单独放在sizeof中，所以表示数组首元素的大小，+0相当于没变，还是数组首元素的地址，地址就是4个字节；
3. arr是数组名，表示数组首元素的地址，*解引用得到数组首元素，类型是char，大小是1个字节；
4. arr[1]是数组第二个元素，类型是char，大小是1个字节；
5. &arr是取出整个数组的地址，地址是4个字节；
6. &arr + 1是跳过该数组的大小，是数组后面位置的地址，地址是4个字节；
7. &arr[0]是数组首元素的地址，+1跳过一个字节，表示数组第二个元素的地址，地址是4个字节。

代码四：

#include <string.h>
int main()
{char arr[] = "abcdef";printf("%d\n", strlen(arr));//6printf("%d\n", strlen(arr + 0));//6printf("%d\n", strlen(*arr));//错误printf("%d\n", strlen(arr[1]));//错误printf("%d\n", strlen(&arr));//6printf("%d\n", strlen(&arr + 1));//随机值printf("%d\n", strlen(&arr[0] + 1));//5return 0;
}

以下是在x86环境下的结果

1. arr是数组名，表示数组首元素的地址，strlen(arr)计算的就是字符串arr的字符个数，是6；
2. arr + 0还是数组首元素的地址，所以还是字符串arr的字符个数，是6；
3. arr表示数组首元素的地址，*arr就是数组的首元素，就是’a’,'a’的ascii码值是97，相当于把97作为地址传给了strlen，strlen得到的就是野指针，代码存在问题；
4. 同理，arr[1]是字符’b’,'b’的ascii码值是98,代码有问题；
5. &arr取出的是整个数组的地址，也就是起始位置，所以计算的也
   是字符串arr的字符个数，是6；
6. &arr + 1是跳过了该数组的大小，是数组后面位置的地址，得到的是一个随机数。
7. &arr[0] + 1是第二个字符的地址，所以strlen会总第二个字符开始向后统计字符个数，是5。

代码五：

int main()
{const char* p = "abcdef";printf("%d\n", sizeof(p));//4printf("%d\n", sizeof(p + 1));//4printf("%d\n", sizeof(*p));//1printf("%d\n", sizeof(p[0]));//1printf("%d\n", sizeof(&p));//4printf("%d\n", sizeof(&p + 1));//4printf("%d\n", sizeof(&p[0] + 1));//4return 0;
}

以下是在x86环境下的结果

1. p是指向常量字符串的指针变量，存放的是第一个字符的地址，地址是4个字节；
2. p + 1 是字符’b’的地址，大小是4个字节；
3. *p是第一个字符’a’，类型是char，大小是1个字节；
4. p[0] 就是*(p + 0)，就是第一个字符，类型是char，大小是1个字节；
5. &p是指针变量p的地址，地址是4个字节；
6. &p + 1是跳过指针变量p后的位置的地址，地址是4个字节；
7. &p[0]是第一个字符的地址，+1就是第二个字符的地址，地址是4个字节。

代码六：

#include <string.h>
int main()
{const char* p = "abcdef";printf("%d\n", strlen(p));//6printf("%d\n", strlen(p + 1));//5printf("%d\n", strlen(*p));//错误printf("%d\n", strlen(p[0]));//错误printf("%d\n", strlen(&p));//随机值printf("%d\n", strlen(&p + 1));//随机值printf("%d\n", strlen(&p[0] + 1));//5return 0;
}

以下是在x86环境下的结果

1. p是指向常量字符串的指针变量，存放的是第一个字符的地址，strlen§计算的就是字符串的字符个数；
2. p + 1是第二个字符的地址，所以计算的字符个数是5；
3. *p就是第一个字符’a’，代码存在问题；
4. p[0]也是’a’，代码也会错误；
5. &p是指针变量p的地址，与字符串关系不大，从p的起始地址开始，向后一直到’\0’的字符个数，是随机值；
6. 同理&p + 1是跳过该指针变量的大小，p后面位置的地址，还是随机值；
7. &p[0] + 1第二个字符的地址，所以计算的字符个数是5。

结语：sizeof 和 strlen 的区别 章节到这里就结束了。
本人才疏学浅，文章中有错误和有待改进的地方欢迎大家批评和指正，非常感谢您的阅读！如果本文对您又帮助，可以高抬贵手点点赞和关注哦！