sizeof 和 strlen 经常被放在同一道题里比较,但它们回答的不是同一个问题。sizeof 问“这个类型占多少字节”,只看类型;strlen 问“从这个地址开始,\0 之前有多少字符”,必须真的去读内存。前者在编译期就能给出答案,后者找不到 \0 就没有答案。

sizeofstrlen
身份操作符,语言的一部分库函数,需要 <string.h>
计算对象类型或表达式所占的字节数\0 之前的字符个数
是否读内存通常不读,不求值必须逐个读到 \0
找不到 \0不受影响继续越界读,行为未定义
结果类型size_tsize_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)int4
sizeof(a + 1)int *8
sizeof(a[1])int4
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)char1
sizeof(arr[1])char1
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)char1
sizeof(p[0])char1
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])int4
sizeof(a[0])int[4]16
sizeof(a[0] + 1)int *8
sizeof(*(a[0] + 1))int4
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 移一格再取值。三者只差括号的位置,结果可以完全不同。做题时按“类型 + 改谁”两栏记账,比凭语感读可靠。