• sizeof和strlen求取数组&指针之辨析

    目录

    一维数组中sizeof Vs  strlen

    整型数组sizeof

    字符数组

    sizeof

    strlen 

    字符串数组

    sizeof

    strlen 

    字符串的指针char *p

    sizeof

    strlen 

    二维数组中sizeof 

    总结

    今天主要来讲题目主要是数组&指针辨析题和笔试题。🆗最近心情有点焦虑。大家一定专注眼前的事情，别太焦虑。

    一维数组中sizeof Vs  strlen

    数组名：就是数组首元素的地址，但是有2个例外。

    1.sizeof(数组名），这里的数组名表示整个数组，sizeof(数组名）计算的时整个数组的大小，单位是字节。

    2.&数组名，这里的数组名表示整个数组，&数组名取出的是整个数组的地址。

    int arr[5] ={1,2,3,4,5};

    sizeof(arr)时，arr指的是整个数组，20字节。

    &arr时，arr指的是整个数组的地址。

    关于strlen和sizeof

    • sizeof

    sizeof是操作符。
    sizeof计算的占用内存的大小，单位是字节。
    计算字符串是包括\0和\0之前的出现的字符个数。
    计算字符是字符的个数。
    sizeof计算的对象是什么类型都行。

    • strlen

    strlen是库函数。
    strlen是统计字符串长度的。
    strlen遇到\0才停止计算。
    strlen只能针对字符串，计算字符串是不包括\0。
    strlen计算字符时，遇不到\0，所以随机值。
    strlen是不能计算整形和字符数组的长度的，因为遇到\0才停止。

    • 注意
    • strlen求字符串长度时，统计的是在字符串\0之前的出现的字符个数
    • sizeof求字符串长度时，统计的是包括\0和\0之前的出现的字符个数
    • 必须传地址给strlen,而传合法写法给sizeof均可。

    整型数组sizeof

    1. //一维数组
    2. int a[] = {1,2,3,4};
    3. printf("%d\n",sizeof(a));
    4. printf("%d\n",sizeof(a+0));
    5. printf("%d\n",sizeof(*a));
    6. printf("%d\n",sizeof(a+1));
    7. printf("%d\n",sizeof(a[1]));
    8. printf("%d\n",sizeof(&a));
    9. printf("%d\n",sizeof(*&a));
    10. printf("%d\n",sizeof(&a+1));
    11. printf("%d\n",sizeof(&a[0]));
    12. printf("%d\n",sizeof(&a[0]+1))
    1. #include
    2. int main()
    3. {
    4. 	//一维数组
    5. 	int a[] = { 1,2,3,4 };
    6. 	printf("%d\n", sizeof(a));//✔
    7. 	//sizeof(数组名）表示整个数组，数组名a单独放在sizeof内部，计算的是整个数组的大小单位是字节，16字节
    8. 	//4个元素，每个元素是int类型（4个字节），16个字节
    9. 	//16
    10. 	printf("%d\n", sizeof(a + 0));
    11. 	//sizof(a+0),数组名a并非单独放在sizeof内部，也没有&，a表示数组首元素的地址，+0还是首元素的地址，地址无论何种类型，大小都是4/8个字节
    12. 	//4/8字节
    13. 	printf("%d\n", sizeof(*a));
    14. 	//sizeof(*a),数组名a并非单独放在sizeof内部，也没有&，a表示数组首元素的地址，*a表示解引用首元素的地址即找到第一个元素，就是1，一个整型元素的大小就是4个字节。
    15. 	//4字节
    16. 	//*a==*(a+0)==a[0]
    17. 	printf("%d ", sizeof(a + 1));//地址++和*地址++✔
    18. 	//sizeof(a+1),数组名a并非单独放在sizeof内部，也没有&,a表示首元素的地址，a+1表示第二个元素的地址，地址无论是何种类型，大小都是4/8个字节
    19. 	//4/8个字节--8个字节（64位）
    20. 	//a+1 == &a[1] 是第二个元素的地址
    21. 	//指向哪里？
    22. 	printf("%d\n", sizeof(*a + 1));
    23. 	//*a是首元素地址解引用为首元素，+1也好，++也罢。都只是往后移动一位4个字节，并没有说1+1=2 赋值这样，计算第二个元素的地址
    24. 	//4个字节
    25. 	printf("%d\n", sizeof(a[1]));
    26. 	//sizeof(a[1]),a[1]下标引用操作符，数组的下标从0开始，所以a[1]指的是第二个元素2，一个整型元素的大小是4个字节
    27. 	//4个字节
    28. 	printf("%d\n", sizeof(&a));//✔
    29. 	//sizeof(&a),a表示整个数组，&a就是把整个数组的地址都取出来，无论怎样还是表示地址，地址无论是何种类型，大小都是4/8个字节
    30. 	//4/8个字节
    31. 	//数组的地址 和 数组首元素的地址 的本质区别是类型的区别 并非大小的区别
    32. 	//a --- int* --指针--          int*p =a;解引用访问的是一个整型的大小
    33. 	//&a --- int(*)[4]--指针数组--       int*p[4]= &a;解引用访问的是一个数组的大小
    34. 	//但是对于p来说，都是存放一个地址，数组首元素的地址也好，整个数组的地址也好，都是一个地址，大小都是4/8个字节
    35. 	printf("%d\n", sizeof(*&a));
    36. 	//sizeof(*&a),a表示整个数组，&a就是把整个数组的地址都取出来，*&a就是把整个数组的地址都解引用，表示整个数组的元素，16个字节
    37. 	//16字节
    38. 	//*和&抵消了
    39. 	printf("%d\n", sizeof(&a + 1));//✔
    40. 	//sizeof(&a+1),a表示整个数组的元素，&a就是把整个数组的地址都取出来，+1就是跳过一整个a数组的元素，指向跳过后的地址处，
    41. 	//无论怎样还是表示地址，地址无论是何种类型，大小都是4/8个字节
    42. 	//4/8个字节
    43. 	//指向哪里？
    44. 	printf("%d\n", sizeof(&a[0]));
    45. 	//sizeof(&a[0]),操作符的优先级a先和[]，下标引操作符结合，得到元素1；再和&结合，得到1的地址。也就是首元素的地址。
    46. 	//无论怎样还是表示地址，地址无论是何种类型，大小都是4/8个字节
    47. 	//4/8个字节
    48. 	printf("%d\n", sizeof(&a[0] + 1));
    49. 	//sizeof(&a[0]+1),同上，得到首元素地址，+1得到第二个元素的地址。
    50. 	//无论怎样还是表示地址，地址无论是何种类型，大小都是4/8个字节
    51. 	//4/8个字节
    52. 	//&a[1]
    53. 	//&a[0]+1
    54. 	//a+1
    55. 	return 0;
    56. }
    • sizeof(数组名），数组名表示整个数组，计算的是整个数组的大小。
    • &数组名，数组名表示整个数组的地址。
    • 除了以上两种情况，其他时候的数组名都是首元素的地址。 
      1. printf("%d\n", sizeof(a));//16字节
      2. printf("%d\n", sizeof(&a));//4/8个字节
    •  不要夹在门缝里看地址，无论是何种类型的地址，char* int* double*等都是4/8个字节
    •  在32位的平台下，4个字节。
    •  在64位的平台下，8给字节。 
      1. 	printf("%d\n", sizeof(&a));
      2.     printf("%d\n", sizeof(a + 0));
    •  关于*p++和p++,也就是地址++和数组元素++
    •  关于地址++和数组元素++，注意数组元素++，并不是在元素本生数值上+1，也没有赋值。
    •  对于字符串的逆置的还可以回顾一下，right++和left++,以及赋值和改变的问题。
    •  关于数组名++和&数组名++所指向的位置见下图                                                                    我们需要注意的是地址++取决于指针的类型 
      1.     printf("%d ", sizeof(a + 1));
      2. 	printf("%d\n", sizeof(*a + 1));
      3. 	printf("%d\n", sizeof(&a + 1));//✔

    字符数组

    ——字符数组是没有\0

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = { 'a','b','c','d','e','f' };
    5. 	printf("%d\n", sizeof(arr));
    6. 	printf("%d\n", sizeof(arr + 0));
    7. 	printf("%d\n", sizeof(*arr));
    8. 	printf("%d\n", sizeof(arr[1]));
    9. 	printf("%d\n", sizeof(&arr));
    10. 	printf("%d\n", sizeof(&arr + 1));
    11. 	printf("%d\n", sizeof(&arr[0] + 1));
    12.  
    13. 	printf("%d\n", strlen(arr));
    14. 	printf("%d\n", strlen(arr + 0));
    15. 	printf("%d\n", strlen(*arr));
    16. 	printf("%d\n", strlen(arr[1]));
    17. 	printf("%d\n", strlen(&arr));
    18. 	printf("%d\n", strlen(&arr + 1));
    19. 	printf("%d\n", strlen(&arr[0] + 1));
    20. 	return 0;
    21. }

    sizeof

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = { 'a','b','c','d','e','f' };//6
    5. 	printf("%d\n", sizeof(arr));//✔
    6. 	//sizeof(arr),数组名arr单独放在sizeof内部，指的是整个数组，计算的是整个数组的元素，6个字节
    7. 	printf("%d\n", sizeof(arr + 0));//✔
    8. 	//sizeof(arr+0),arr指的是首元素地址，+0还是首元素地址，地址无论何种类型，大小就是4/8个字节
    9. 	//arr是首元素的地址 == &arr[0].是地址就是4/8个字节
    10. 	//char*
    11. 	//指针变量的大小和类型无关，不管什么类型的指针变量，大小都是4/8个字节
    12. 	//指针变量是用来存放地址的，地址存放需要多大空间，指针变量的大小就是几个字节。
    13. 	//32位环境下，地址是32个二进制，需要4个字节，所以指针变量的大小就是几个字节
    14. 	//32位环境下，地址是64个二进制，需要8个字节，所以指针变量的大小就是几个字节
    15. 	//🆗🆗请不要在门缝里看指针，把指针看扁了。
    16. 	printf("%d\n", sizeof(*arr));
    17. 	//sizeof(*arr),arr指的是首元素地址，*arr是数组的第一个元素，1个字节
    18. 	printf("%d\n", sizeof(arr[1]));
    19. 	//数组第2个元素，数组的下标从0开始，1个字节
    20. 	printf("%d\n", sizeof(&arr));//✔
    21. 	//&arr是数组的地址，指的是整个数组的地址，数组指针，char(*p)[6]=地址无论何种类型，大小就是4/8个字节
    22. 	printf("%d\n", sizeof(&arr + 1));
    23. 	//&arr+1 是跳过数组后的地址，地址无论何种类型，大小就是4/8个字节
    24. 	printf("%d\n", sizeof(&arr[0] + 1));
    25. 	//第二个元素的地址，地址无论何种类型，大小就是4/8个字节
    26. 	return 0;
    27. }
    • 指针变量的大小和类型无关，不管什么类型的指针变量，大小都是4/8个字节。
    • 指针变量的计算和类型有关。
    • 指针变量是用来存放地址的，地址存放需要多大空间，指针变量的大小就是几个字节。   
    • 32位环境下，地址是32个二进制，需要4个字节，所以指针变量的大小就是几个字节。
    • 32位环境下，地址是64个二进制，需要8个字节，所以指针变量的大小就是几个字节。

    strlen 

     我们在模拟实现strlen的功能时，写道size_t my_strlen(const char* str)                                            所以strlen接收的是字符指针，必须传地址给strlen

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = { 'a','b','c','d','e','f' };//6个没有\0
    5. 	printf("%d\n", strlen(arr));
    6. 	//arr指的是首元素的地址
    7. 	//strlen从首元素往后计算字符的个数遇到\0停止，但是在此时内存中我们不知道\0在何处
    8. 	// 此处求出应该是随机值
    9. 	printf("%d\n", strlen(arr + 0));
    10. 	//arr+0指的是首元素的地址。
    11. 	//strlen从首元素往后计算字符的个数遇到\0停止，但是在此时内存中我们不知道\0在何处
    12. 	// 此处求出应该是随机值
    13. 	printf("%d\n", strlen(*arr));
    14. 	//*arr指的是首元素。
    15. 	//把'a'的ascll码值97 传给strlen,因为strlen只接受地址。
    16. 	//所以站在strlen的角度上，认为97是一个地址，是非法地址，直接访问发生非法访问，所以会报错。err
    17. 	printf("%d\n", strlen(arr[1]));
    18. 	//arr[1]是首元素  'b'-98
    19. 	//同上err
    20. 	printf("%d\n", strlen(&arr));
    21. 	//&arr是整个数组的地址，数值上和首元素地址一样。
    22. 	//所以，strlen从首元素往后计算字符的个数遇到\0停止，但是在此时内存中我们不知道\0在何处
    23. 	// 此处求出应该是随机值
    24. 	printf("%d\n", strlen(&arr + 1));
    25. 	//&arr+1,整个数组的地址+1，跳过整个数组，指向跳过整个数组之后的元素
    26. 	// 整个数组的地址是字符数组指针类型,	// 而我们的strlen接收的是字符指针类型
    27. 	// char(*)[6]                              const char*
    28. 	//所以这里会发生类型转化
    29.  
    30. 	//那我们更加不知道在内存何处会遇到\0，所以随机值
    31. 	printf("%d\n", strlen(&arr[0] + 1));
    32. 	//&arr[0]+1,首元素地址+1，即指向第二个元素的地址。
    33. 	//所以，strlen从第二个元素往后计算字符的个数遇到\0停止，但是在此时内存中我们不知道\0在何处
    34. 	// 此处求出应该是随机值
    35. 	return 0;
    36. }
    • strlen所接受的数据，站在strlen的角度上会全部当作地址。
    • strlen所接收的地址，是const char* 字符指针类型的，当其他类型传入时，会发生类型转换。
    • arr+1和&arr+1在内存中所指向的空间内存分布是怎样的。要清晰的知道。 

    字符串数组

    ——字符串数组有隐藏的\0

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = "abcdef";
    5. 	printf("%d\n", sizeof(arr));
    6. 	printf("%d\n", sizeof(arr + 0));
    7. 	printf("%d\n", sizeof(*arr));
    8. 	printf("%d\n", sizeof(arr[1]));
    9. 	printf("%d\n", sizeof(&arr));
    10. 	printf("%d\n", sizeof(&arr + 1));
    11. 	printf("%d\n", sizeof(&arr[0] + 1));
    12. 	return 0;
    13. }
    14. #include
    15. int main()
    16. {
    17. 	char arr[] = "abcdef";
    18. 	printf("%d\n", strlen(arr));
    19. 	printf("%d\n", strlen(arr + 0));
    20. 	printf("%d\n", strlen(*arr));
    21. 	printf("%d\n", strlen(arr[1]));
    22. 	printf("%d\n", strlen(&arr));
    23. 	printf("%d\n", strlen(&arr + 1));
    24. 	printf("%d\n", strlen(&arr[0] + 1));
    25. 	return 0;
    26. }

    sizeof

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = "abcdef";
    5. 	printf("%d\n", sizeof(arr));//7
    6. 	//计算的是整个数组的大小包括\0
    7. 	printf("%d\n", sizeof(arr + 0));//4/8
    8. 	//sizeof计算的是一个变量所占空间的大小
    9. 	//计算的是首元素地址的大小4/8
    10. 	printf("%d\n", sizeof(*arr));//1
    11. 	//计算的是首元素的大小1
    12. 	printf("%d\n", sizeof(arr[1]));//1
    13. 	//计算的是第二个元素的大小
    14. 	printf("%d\n", sizeof(&arr));//4/8
    15. 	//计算整个数组的地址4/8
    16. 	printf("%d\n", sizeof(&arr + 1));//4/8
    17. 	//计算跳过整个数组后指向的地址4/8
    18. 	printf("%d\n", sizeof(&arr[0] + 1));//4/8
    19.     printf("%d\n", sizeof(arr + 1));
    20. 	//计算跳过首元素地址指向第二元素的地址4/8
    21. 	return 0;
    22. }

     

    strlen 

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = "abcdef";
    5. 	printf("%d\n", strlen(arr));//6
    6. 	//首元素的地址往后计算直到遇到\0停止
    7. 	printf("%d\n", strlen(arr + 0));//6
    8. 	//首元素的地址往后计算直到遇到\0停止
    9. 	printf("%d\n", strlen(*arr));//'a'——97
    10. 	//err
    11. 	printf("%d\n", strlen(arr[1]));//'b'——98
    12. 	//err
    13. 	printf("%d\n", strlen(&arr));//6
    14. 	//整个数组的地址在数值上 == 首元素地址 往后计算直到遇到\0停止
    15. 	printf("%d\n", strlen(&arr + 1));//随机值
    16. 	//跳过整个数组后指向的地址，后面什么时候遇到\0未知，随机值
    17. 	printf("%d\n", strlen(&arr[0] + 1));//5
    18. 	printf("%d\n", strlen(arr + 1));//5
    19. 	//指向第二个元素的地址，往后计算直到遇到\0停止
    20. 	return 0;
    21. }

    字符串的指针char *p

    在这之前可以回顾一下字符指针

    C语言之指针进阶篇（1）_唐棣棣的博客-CSDN博客

    1. #include
    2. int main()
    3. {
    4. 	char* p = "abcdef";
    5. 	printf("%d\n", sizeof(p));
    6. 	printf("%d\n", sizeof(p + 1));
    7. 	printf("%d\n", sizeof(*p));
    8. 	printf("%d\n", sizeof(p[0]));
    9. 	printf("%d\n", sizeof(&p));
    10. 	printf("%d\n", sizeof(&p + 1));
    11. 	printf("%d\n", sizeof(&p[0] + 1));
    12.  
    13. 	printf("%d\n", strlen(p));
    14. 	printf("%d\n", strlen(p + 1));
    15. 	printf("%d\n", strlen(*p));
    16. 	printf("%d\n", strlen(p[0]));
    17. 	printf("%d\n", strlen(&p));
    18. 	printf("%d\n", strlen(&p + 1));
    19. 	printf("%d\n", strlen(&p[0] + 1));
    20. 	return 0;
    21. }

    sizeof

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = "abcdef";
    5. 	char* p = "abcdef";
    6. 	printf("%d\n", sizeof(p));//4/8
    7. 	//p是字符指针，存放的是地址，大小是4/8
    8. 	//p指的是首元素的地址
    9. 	printf("%d\n", sizeof(arr));//7
    10.  
    11. 	printf("%d\n", sizeof(p + 1));//4/8
    12. 	//p+1，计算的是第二个元素的地址，大小4/8
    13.  
    14. 	printf("%d\n", sizeof(*p));//1
    15. 	//首元素'a',指针解引用，看指针的类型，char*,是访问1个字节
    16. 	printf("%d\n", sizeof(p[0]));//1
    17.  
    18. 	printf("%d\n", sizeof(&p));//4/8
    19. 	printf("%d\n", sizeof(&p + 1));//4/8
    20. 	printf("%d\n", sizeof(&p[0] + 1));//4/8
    21. 	return 0;
    22. }
    • 对指针解引用，看指针的类型，再决定访问几个字节。
    • 指针计算，看指针的类型，再决定跳过几个字节。
    • 指针的大小，无论什么类型，都是4/8个字节

     

    strlen 

    1. #include
    2. int main()
    3. {
    4. 	char arr[] = "abcdef";
    5. 	char* p = "abcdef";
    6. 	printf("%d\n", strlen(p));//6
    7. 	printf("%d\n", strlen(p + 1))//5
    8. 	printf("%d\n", strlen(*p));//err
    9. 	printf("%d\n", strlen(p[0]));//err
    10. 	printf("%d\n", strlen(&p));//随机值
    11. 	printf("%d\n", strlen(&p + 1));//随机值
    12. 	printf("%d\n", strlen(&p[0] + 1));//5
    13. 	return 0;
    14. }

     

    二维数组中sizeof 

    1. #include
    2. int main()
    3. {
    4. 	int a[3][4] = { 0 };
    5. 	printf("%zd\n", sizeof(a));
    6. 	printf("%zd\n", sizeof(a[0][0]));
    7. 	printf("%zd\n", sizeof(a[0]));
    8. 	printf("%zd\n", sizeof(a[0] + 1));
    9. 	printf("%zd\n", sizeof(*(a[0] + 1)));
    10. 	printf("%zd\n", sizeof(a + 1));
    11. 	printf("%zd\n", sizeof(*(a + 1)));
    12. 	printf("%zd\n", sizeof(&a[0] + 1));
    13. 	printf("%zd\n", sizeof(*(&a[0] + 1)));
    14. 	printf("%zd\n", sizeof(*a));
    15. 	printf("%zd\n", sizeof(a[3]));
    16. 	return 0;
    17. }
    18. //sizeof的返回值是size_t ,所以打印最好使用%zd来打印
    1. //二维数组
    2. #include
    3. int main()
    4. {
    5. 	int a[3][4] = { 0 };
    6. 	printf("%zd\n", sizeof(a));//4*3*4=48
    7. 	//二维数组名 单独放在sizeof内部中，计算的是整个数组的大小，单位是字节。
    8. 	printf("%zd\n", sizeof(a[0][0]));//4
    9. 	//第一行第一列的元素，计算一个元素的大小，整型，单位字节
    10.  
    11.  
    12. 	printf("%zd\n", sizeof(a[0]));//16
    13. 	//第一行的数组名 a[0]单独放在sizeof内部，计算的是整个第一行的大小，4*4=16
    14. 	//a[0]就表示整个第一行这个一维数组，sizeof(a[0])计算的整个第一行这个一维数组的大小
    15. 	printf("%zd\n", sizeof(a[0] + 1));//4/8
    16. 	//第一行的数组名没有单独放在sizeof内部，也没有&，表示第一行首元素的地址
    17. 	//也就是第一行第一个元素的地址 a[0]== &a[0][0]   a[0]+1== &a[0][1]
    18. 	//+1表示第一行第二个元素的地址。
    19. 	printf("%zd\n", sizeof(*(a[0] + 1)));//4
    20. 	//*解引用，表示第二个元素
    21.  
    22.  
    23.  
    24. 	printf("%zd\n", sizeof(a + 1));//4/8
    25. 	//a没有单独放在sizeof内部，
    26. 	// 表示二维数组首元素地址，即第一行的地址,a的类型int(*)[4]---数组指针
    27. 	// +1表示第二行的地址。
    28. 	printf("%zd\n", sizeof(*(a + 1)));//4*4=16
    29. 	//解引用，表示整个第二行的大小，整型4*4
    30. 	//*（a+1) == a[1]
    31. 	//sizeof(a[1]) --- a[1]表示第二行的数组名，单独放在sizeof内部，
    32.     //即计算的是整个第二行的大小
    33.  
    34. 	printf("%zd\n", sizeof(&a[0] + 1));//4/8
    35. 	//a[0]表示第一行的数组名，&表示第一行的地址，类型是int(*)[4],
    36. 	//+1表示第二行的地址,类型int(*)[4]
    37. 	printf("%zd\n", sizeof(*(&a[0] + 1)));//16
    38. 	//解引用，表示第二行的大小
    39.  
    40.  
    41. 	printf("%zd\n", sizeof(*a));//16
    42. 	//a并非单独放在sizeof内部，a表示二维数组首元素地址，即第一行的地址，
    43. 	// 解引用表示第一行的大小
    44. 	//*a == *(a+0) == a[0]
    45.  
    46. 	printf("%zd\n", sizeof(a[3]));//4/8
    47. 	//与a[0]同一类型int * [4],整行的地址，4/8
    48. 	//sizeof根据表达式的类型属性来计算大小的，并不会真正访问第四行，不会越界
    49. 	//a[3]    a[0]
    50. 	//int [4]     int[4]
    51.  
    52. 	return 0;
    53. }

     

    总结

    一维数组  int arr[7]={0};          二维数组      int arr[3][4]={0};

    • 数组名单独放在sizeof内部 表示是一个数组(数组元素个数✖数组元素类型所占空间大小) 
    • &数组名 取出的是一整个数组的地址（数值上与首元素地址相同 ，+1之后可看出差别）
    • 一维数组数组名arr,先判断是否单独放在sizeof内部，&数组名。除了以上情况都是首元素地址
    • 二维数组数组名arr/arr[0]/arr[1]/arr[2]，同上
    • 二维数组内存中连续存储（实际图），数组的数组，找行和列时下标从0开始（脑中图）
    • 写法arr[2] = *(arr+2)

    指针

    • 对指针解引用，看指针的类型，再决定访问几个字节。
    • 指针计算，看指针的类型，再决定跳过几个字节。
    • 指针的大小，无论什么类型，都是4/8个字节

     字符和字符串数组

    • 字符数组里没有\0  字符串数组里有隐藏的\0 

    sizeof和strlen

    • sizeof

    sizeof是操作符。
    sizeof计算的占用内存的大小，单位是字节。
    计算字符串是包括\0和\0之前的出现的字符个数。
    计算字符是字符的个数。
    sizeof计算的对象是什么类型都行，sizeof计算的表达式所占空间大小，根据表达式类型属性来确定数值在内存中所占空间的大小。

    • strlen

    strlen是库函数。
    strlen是统计字符串长度的。
    strlen遇到\0才停止计算。
    strlen只能针对字符串，计算字符串是不包括\0。
    strlen计算字符时，遇不到\0，所以随机值。
    strlen是不能计算整形和字符数组的长度的，因为遇到\0才停止。

    • 注意
    • strlen求字符串长度时，统计的是在字符串\0之前的出现的字符个数
    • sizeof求字符串长度时，统计的是包括\0和\0之前的出现的字符个数
    • 必须传地址给strlen,而传合法写法给sizeof均可。

    ✔✔✔✔✔最后，感谢大家的阅读，若有错误和不足，欢迎指正！上面的题目有很多相似之处，所以看懂一组，相信后面都会。少说话多做事🆗🆗

    代码------→【gitee:唐棣棣 (TSQXG) - Gitee.com】

    联系------→【邮箱：2784139418@qq.com】

  • 相关阅读:
    socket编程
    初学者常见异常丨传说中的NPE空指针异常怎么解决？
    Centos7下安装使用K3S
    支持向量机：原理与python案例
    代码随想录算法训练营第二十五天| LeetCode216. 组合总和 III、LeetCode17. 电话号码的字母组合
    linux学习3 — ubuntu中的文件
    智力考验看成语猜古诗句微信小程序源码
    map-reduce中的组件
    带头双向循环链表讲解-思路清晰+画图+代码实现
    python让女友照片飞来飞去
  • 原文地址：https://blog.csdn.net/m0_74841364/article/details/132877581