sizeof 和 strlen 经常被放在同一道题里比较,但它们回答的不是同一个问题。sizeof 问“这个类型占多少字节”,只看类型;strlen 问“从这个地址开始,\0 之前有多少字符”,必须真的去读内存。前者在编译期就能给出答案,后者找不到 \0 就没有答案。
sizeof | strlen | |
|---|---|---|
| 身份 | 操作符,语言的一部分 | 库函数,需要 <string.h> |
| 计算对象 | 类型或表达式所占的字节数 | \0 之前的字符个数 |
| 是否读内存 | 通常不读,不求值 | 必须逐个读到 \0 |
找不到 \0 | 不受影响 | 继续越界读,行为未定义 |
| 结果类型 | size_t | size_t |
下面的数值按 64 位平台给出:指针 8 字节,int 4 字节。换到 32 位平台,所有指针大小和地址步长都要重算。
sizeof 不求值,越界下标也能算
sizeof 的操作数可以是表达式,也可以是类型名。操作数是类型名时括号不能省,sizeof(int) 合法,sizeof int 不合法;操作数是表达式时括号可以省,sizeof a 和 sizeof(a) 等价。
关键规则是:除非操作数的类型是变长数组,sizeof 不会对表达式求值。它只需要推出类型,再算这个类型占多少字节,那块内存根本不去读。
#include <stdio.h>
int main(void)
{
int a[3][4] = {0};
int x = 0;
printf("%zu\n", sizeof(a[3])); /* 16,类型是 int[4],没有越界访问 */
printf("%zu\n", sizeof(x++)); /* 4,x 不会自增 */
printf("%d\n", x); /* 0 */
return 0;
}a[3] 的下标越界,但它有类型 int[4],sizeof 按类型算出 16。这不是“未定义行为碰巧没出事”,是这个访问压根没有发生。sizeof(x++) 同理,自增被整个丢掉。
唯一会执行操作数的是变长数组(VLA)。int n; scanf("%d", &n); int a[n]; 里的 sizeof(a) 必须在运行期算 n * sizeof(int)。考试问“sizeof 是不是总在编译期求值”,准确答案是“通常,VLA 除外”。
sizeof 的结果类型是 size_t,打印用 %zu。课件里清一色用 %d 打印 sizeof 的结果,在 64 位平台上属于格式串与实参类型不匹配,值小的时候看不出问题。课件的示例还把 #include 拼成了 #inculde,照抄会直接编译失败。
sizeof 不能用在函数类型或不完整类型上:sizeof(void) 不合法,sizeof(main) 也不合法,函数没有“大小”;sizeof(&main) 是 8,加了取地址符就变成指针。
strlen 找不到 \0 时,题目本身就没有答案
size_t strlen(const char *str);它从 str 指向的地址开始向后数,数到 \0 停止,不把 \0 算进长度。参数是 const char *,函数只读。找不到 \0 时,它会一直读到数组之外,标准把这种读法定义为未定义行为。
#include <stdio.h>
#include <string.h>
int main(void)
{
char arr1[3] = {'a', 'b', 'c'};
char arr2[] = "abc";
size_t i;
printf("%zu\n", strlen(arr2)); /* 3 */
printf("%zu\n", sizeof(arr1)); /* 3 */
printf("%zu\n", sizeof(arr2)); /* 4,包含结尾的 \0 */
for (i = 0; i < 3; i++)
{
printf("%c", arr1[i]);
}
printf("\n");
return 0;
}strlen(arr1) 不能写进这个程序:arr1 三个格子全是字符,没有 \0,函数会继续往后读栈上的内容,直到碰巧遇到一个 0。结果取决于编译器和运行环境,没有可背的标准答案。
还有一类表达式连“值是多少”都谈不上,因为它们不能通过编译:把 char 传给 const char * 参数,或者把 char (*)[N] 传给 const char *,都是类型不兼容,编译器要求诊断。看到 strlen 的参数里带着 *、& 或下标,先做类型检查,再谈数值。
数组名的三条规则
sizeof(数组名):数组名代表整个数组,算整个数组的字节数。&数组名:取到整个数组的地址,类型是“指向数组的指针”。- 除此之外,数组名都转换成首元素地址。
这条规则决定下面所有题的第一步:先看数组名有没有被 sizeof 或 & 单独包住,没有被包住就先退化。
一维数组
int a[] = {1, 2, 3, 4};| 表达式 | 类型 | 结果 |
|---|---|---|
sizeof(a) | int[4] | 16 |
sizeof(a + 0) | int * | 8 |
sizeof(*a) | int | 4 |
sizeof(a + 1) | int * | 8 |
sizeof(a[1]) | int | 4 |
sizeof(&a) | int (*)[4] | 8 |
sizeof(*&a) | int[4] | 16 |
sizeof(&a + 1) | int (*)[4] | 8 |
sizeof(&a[0]) | int * | 8 |
sizeof(&a[0] + 1) | int * | 8 |
sizeof(a + 0) 和 sizeof(*&a) 是两条分界线:+ 0 让数组名退化,*& 又把指针解回数组。sizeof 只看括号里最终表达式的类型,中间发生过什么转换不影响结果。
字符数组的两组写法
第一组是没有 \0 的字符数组:
char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};| 表达式 | 类型 | 结果 |
|---|---|---|
sizeof(arr) | char[6] | 6 |
sizeof(arr + 0) | char * | 8 |
sizeof(*arr) | char | 1 |
sizeof(arr[1]) | char | 1 |
sizeof(&arr) | char (*)[6] | 8 |
sizeof(&arr + 1) | char (*)[6] | 8 |
sizeof(&arr[0] + 1) | char * | 8 |
同一组表达式换成 strlen,只有类型合法的那些才谈得上扫描:
| 表达式 | 情况 |
|---|---|
strlen(arr) | 从 'a' 开始向后找 \0,数组内没有,越界读,未定义 |
strlen(arr + 0) | 同上,起点仍是 arr |
strlen(*arr) | 实参是 char,类型不兼容,编译不过 |
strlen(arr[1]) | 同上 |
strlen(&arr) | 实参类型 char (*)[6],与 const char * 不兼容,需要强转;地址与 arr 相同,强转后仍然找不到 \0 |
strlen(&arr + 1) | 起点在数组之后,越界读,未定义 |
strlen(&arr[0] + 1) | 从 'b' 开始,仍无 \0,越界读,未定义 |
第二组是字符串初始化的数组:
char arr[] = "abcdef";sizeof 的结果整体比上一组多 1:sizeof(arr) 是 7,其余指针和元素的结果不变,仍是 8、1、1、8、8、8。多出来的那一格是结尾的 \0。
strlen 这组才有正常答案:strlen(arr) 和 strlen(arr + 0) 都是 6;strlen(&arr[0] + 1) 从 'b' 开始,是 5;strlen(&arr) 类型不兼容,强转后地址等于 arr,结果 6;strlen(&arr + 1) 从整个数组之后开始,越界读,未定义;strlen(*arr)、strlen(arr[1]) 类型不兼容,编译不过。
字符串指针
char *p = "abcdef";p 是指针变量,存的是字面量首字符的地址。sizeof(p) 量的是指针自己,不是字符串:
| 表达式 | 类型 | 结果 |
|---|---|---|
sizeof(p) | char * | 8 |
sizeof(p + 1) | char * | 8 |
sizeof(*p) | char | 1 |
sizeof(p[0]) | char | 1 |
sizeof(&p) | char ** | 8 |
sizeof(&p + 1) | char ** | 8 |
sizeof(&p[0] + 1) | char * | 8 |
strlen 这组:strlen(p) 是 6,strlen(p + 1) 是 5,strlen(&p[0] + 1) 也是 5。strlen(*p) 和 strlen(p[0]) 把 char 当地址传,类型不兼容;strlen(&p) 把指针变量自己的地址交给 strlen,强转后它会去读 p 这个变量所占的 8 个字节,把地址的字节当成字符串内容,结果没有意义;strlen(&p + 1) 从 p 之后开始读,越界。
char *p = "abcdef"; 在 C 里能编译,因为字面量类型是 char[N];但字面量所在的内存不可写,p[0] = 'A' 是未定义行为。接口应当写成 const char *p。
二维数组
int a[3][4] = {0};a 的元素是一行 int[4],数组名退化后是 int (*)[4]。
| 表达式 | 类型 | 结果 |
|---|---|---|
sizeof(a) | int[3][4] | 48 |
sizeof(a[0][0]) | int | 4 |
sizeof(a[0]) | int[4] | 16 |
sizeof(a[0] + 1) | int * | 8 |
sizeof(*(a[0] + 1)) | int | 4 |
sizeof(a + 1) | int (*)[4] | 8 |
sizeof(*(a + 1)) | int[4] | 16 |
sizeof(&a[0] + 1) | int (*)[4] | 8 |
sizeof(*(&a[0] + 1)) | int[4] | 16 |
sizeof(*a) | int[4] | 16 |
sizeof(a[3]) | int[4] | 16 |
a[0] 是“第一行”这个数组对象,所以 sizeof(a[0]) 是 16;它一旦参与 + 1 就退化成 int *,变成 8。a + 1 跳过一整行,类型仍是数组指针,大小是 8;*(a + 1) 解回第二行,大小回到 16。a[3] 越界,但类型仍是 int[4],sizeof 不求值,所以照样是 16。
指针运算题
跨过整个数组再退回一格
#include <stdio.h>
int main(void)
{
int a[5] = {1, 2, 3, 4, 5};
int *ptr = (int *)(&a + 1);
printf("%d,%d\n", *(a + 1), *(ptr - 1)); /* 2,5 */
return 0;
}&a 的类型是 int (*)[5],加一跨 20 字节,落在整个数组之后。强转成 int * 后步长变 4,ptr - 1 往回退一格,正好是 a[4]。&a + 1 是合法的尾后位置,可以比较、可以相减,不能解引用。
结构体指针加一,加的是结构体的宽度
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
} *p = (struct Test *)0x100000;题目假设 32 位环境、结构体大小 20 字节:
p + 0x1走 20 字节,得到0x100014;(unsigned long)p + 0x1把地址转成整数再加一,得到0x100001;(unsigned int *)p + 0x1按unsigned int走 4 字节,得到0x100004。
三个都写着 +1,差别全在左操作数的类型。题目没写环境时,答案就不是某一个固定地址:结构体大小受对齐影响,指针宽度随平台变化,换到 64 位,char * 从 4 字节变 8,整道题的数值都要重算。
括号里的逗号不是分隔符
#include <stdio.h>
int main(void)
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int *p = a[0];
printf("%d\n", p[0]); /* 1 */
return 0;
}括号里是逗号表达式,不是初始化列表。每个逗号表达式取最右一个值,实际初始化成 {{1, 3}, {5, 0}, {0, 0}},其余元素补 0。p = a[0] 指向第一行首元素,p[0] 是 1。编译器通常会给一条“逗号表达式缺少括号”之类的警告。
两种行宽解释同一块内存
#include <stdio.h>
int main(void)
{
int a[5][5];
int (*p)[4];
p = (int (*)[4])a; /* 课件写的是 p = a; 这行本身不合法 */
printf("%td\n", &p[4][2] - &a[4][2]); /* -4 */
return 0;
}a 的类型是 int (*)[5],赋给 int (*)[4] 是不兼容指针赋值,编译器要求诊断,GCC 直接当错误处理。题目若坚持这么解释,就得显式强转并声明这是题面假设。
同一块内存,a 按每行 5 个 int 看,p 按每行 4 个 int 看:
a[4][2]是第4 × 5 + 2 = 22个 int;p[4][2]是第4 × 4 + 2 = 18个 int;- 两者都是
int *,相减得到18 - 22 = -4。
课件用 %p 和 %d 打印这个差值。差值的类型是 ptrdiff_t,%p 要的是 void *,%d 要的是 int,两个都不匹配;用 %td 一次就够。
二维数组的尾后与第二行
#include <stdio.h>
int main(void)
{
int aa[2][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
printf("%d,%d\n", *(ptr1 - 1), *(ptr2 - 1)); /* 10,5 */
return 0;
}&aa + 1 跨过整个 2×5 数组,退回一格是末尾元素 10。aa + 1 是第二行的地址,*(aa + 1) 是第二行的数组,传给 int * 后退化成首元素地址,退回一格是第一行末尾的 5。
指针数组里的两级指针
#include <stdio.h>
int main(void)
{
char *a[] = {"work", "at", "alibaba"};
char **pa = a;
pa++; /* 指向 a[1] */
printf("%s\n", *pa); /* at */
return 0;
}a 是三个 char * 的数组,pa 指向第一个元素。pa++ 走一个 char * 的宽度,*pa 取出 a[1],指向 "at"。
四次自增和一次回写
#include <stdio.h>
int main(void)
{
char *c[] = {"ENTER", "NEW", "POINT", "FIRST"};
char **cp[] = {c + 3, c + 2, c + 1, c};
char ***cpp = cp;
printf("%s\n", **++cpp); /* POINT */
printf("%s\n", *--*++cpp + 3); /* ER */
printf("%s\n", *cpp[-2] + 3); /* ST */
printf("%s\n", cpp[-1][-1] + 1); /* EW */
return 0;
}这类题要一边算一边记“哪个变量被改成了什么”。初始 cpp 指向 cp[0],cp[0] 存 c + 3。
**++cpp:cpp先自增到cp[1],*++cpp取出c + 2,再解引用得到c[2],指向"POINT"。*--*++cpp + 3:cpp再自增到cp[2],*++cpp取出c + 1;--把这个值减成c并写回cp[2];*得到c[0],指向"ENTER",加 3 得到"ER"。这一步改的是cp[2]里存的指针,不是cpp。*cpp[-2] + 3:cpp停在cp[2],减 2 落在cp[0],值是c + 3,解引用得到c[3],指向"FIRST",加 3 得到"ST"。cpp[-1][-1] + 1:cpp[-1]落在cp[1],值是c + 2;再[-1]落在c[1],指向"NEW",加 1 得到"EW"。
做完后的状态:cpp 在 cp[2],cp[2] 被改成 c,cp[0]、cp[1] 没动。漏掉 cp[2] 那一次回写,后两行就会算错。
自增和指针还有三组容易混的写法:*p++ 等价于 *(p++),先取值、再把 p 移一格;(*p)++ 是元素自增,p 不动;*++p 是先把 p 移一格再取值。三者只差括号的位置,结果可以完全不同。做题时按“类型 + 改谁”两栏记账,比凭语感读可靠。
还没有评论 — 第一条由你来留。