想删就删头像
深入理解 C 语言指针(六):sizeof、strlen 与指针运算辨析封面图

深入理解 C 语言指针(六):sizeof、strlen 与指针运算辨析

学习记录:露露同学的 C 语言笔记
指针的最后一篇。
下文数值表采用常见环境:

  • sizeof(int) == 4。
  • sizeof(char) == 1。
  • 用 P 表示表中相应指针类型的大小,在常见 32 位、64 位程序中通常分别为 4、8 字节。

具体以编译目标为准,不只看电脑或操作系统是不是 64 位。

一、sizeof 的基本用法

【文字解释】

原文“sizeof 只关注占用内存空间的大小,不在乎内存中存放什么数据”这个理解可以保留。

更准确地说,sizeof 根据操作数的类型确定大小,结果以字节为单位,结果类型是 size_t。

【代码 1】表达式和类型名的写法(完整程序)

#include <stdio.h>

int main(void)
{
    int a = 10;

    printf("%lu\n", (unsigned long)sizeof(a));
    printf("%lu\n", (unsigned long)sizeof a);
    printf("%lu\n", (unsigned long)sizeof(int));
    printf("%lu\n", (unsigned long)(sizeof a + 2));
    printf("%lu\n", (unsigned long)sizeof(a + 2));

    return 0;
}

【文字解释】

sizeof a + 2 按下面的形式理解:

(sizeof a) + 2

因此在 int 占 4 字节时,结果为 6。

sizeof(a + 2) 求的是表达式 a + 2 的类型大小。这里表达式类型是 int,结果仍为 4,不是求数值 12 有几位。

原文“sizeof int 不加括号不对”是正确的:

  • 对类型名使用 sizeof,必须写成 sizeof(int)。
  • 对普通表达式,可以写 sizeof a。

【原文】

printf("%d\n", sizeof(a));

【问题】

原文多处用 %d 输出 sizeof 或 strlen 的结果,但它们的结果类型是 size_t,并非一定是 int。

格式与实参类型不匹配,不能因为某次输出正确就认为写法正确。

【改正】

本文为了使用 C89 写法,对这些很小的结果转换为 unsigned long,再用 %lu 输出。

C99 及以后可以直接使用 %zu,但本篇不依赖它。

原文的 Sizeof、Arr 等笔记缩写在代码中统一为实际声明使用的大小写;C 区分大小写。intf 是 printf 的笔误,也在程序中修正。

【运行结果】

在 int 占 4 字节的环境中:

4
4
4
6
4

二、strlen 与字符串结束标记

【文字解释】

原文“strlen 是库函数,需要包含 <string.h>”是正确的。

它读取从指定位置开始的字符串,统计第一个 \0 之前的字符个数,不把结束标记本身计入长度。
不过,字符串的结束字符应写作 \0
空格 ' ' 是普通字符,参与长度统计,不是\0

对比项sizeofstrlen
本身是什么运算符库函数
关注什么类型对应的对象大小字符串结束标记前的字符数
是否计算结尾的 \0若它是字符数组元素,会计入整个数组大小不计入长度
是否读取字符内容本篇固定类型示例不读取操作数的值需要读取字符序列
是否知道数组容量对完整数组操作数可以得到整个数组大小不知道容量,要求传入有效字符串

【代码】原文三个初始化示例(局部示例)

char arr1[] = "abc";
char arr2[3] = "abc";
char arr3[4] = "abc";

【文字解释】

定义实际元素sizeof 结果能否直接用于 strlen
char arr1[] = "abc";a、b、c、\04可以,长度 3
char arr2[3] = "abc";a、b、c3不可以,缺少结束标记
char arr3[4] = "abc";a、b、c、\04可以,长度 3

这里仅把三个原本分别命名为 arr 的示例写成不同名字,方便放在一起比较。

C 中允许恰好用三个字符初始化 char arr2[3],但它不是以零字符结束的字符串。

三、一维整型数组的十个 sizeof 表达式

【代码 2】保留原文的十个表达式(完整程序)

#include <stdio.h>

int main(void)
{
    int a[] = {1, 2, 3, 4};

    printf("%lu\n", (unsigned long)sizeof(a));
    printf("%lu\n", (unsigned long)sizeof(a + 0));
    printf("%lu\n", (unsigned long)sizeof(*a));
    printf("%lu\n", (unsigned long)sizeof(a + 1));
    printf("%lu\n", (unsigned long)sizeof(a[1]));
    printf("%lu\n", (unsigned long)sizeof(&a));
    printf("%lu\n", (unsigned long)sizeof(*&a));
    printf("%lu\n", (unsigned long)sizeof(&a + 1));
    printf("%lu\n", (unsigned long)sizeof(&a[0]));
    printf("%lu\n", (unsigned long)sizeof(&a[0] + 1));

    return 0;
}

【文字解释与结果】

序号表达式sizeof 的操作数是什么类型结果
1sizeof(a)含 4 个 int 的数组16
2sizeof(a + 0)int 指针P
3sizeof(*a)int4
4sizeof(a + 1)int 指针P
5sizeof(a[1])int4
6sizeof(&a)指向整个数组的指针P
7sizeof(*&a)含 4 个 int 的数组16
8sizeof(&a + 1)指向数组的指针P
9sizeof(&a[0])int 指针P
10sizeof(&a[0] + 1)int 指针P

【原文】

“Sizeof 里面除了 &a,其他的都是首元素地址。”

【问题】

不能只看表达式里有没有 &a:

  • *a 是一个整数。
  • *&a 是整个数组。
  • a[1] 也是整数。

【改正】

先判断 sizeof 直接作用的完整表达式是什么类型,再求这个类型的大小。

例如 a + 0 中,a 参与加法时转换成首元素指针;加零后仍是指针。

*&a 则先取得整个数组地址,再解引用得到整个数组,sizeof 直接作用于这个数组,因此结果为 16。

【原文】

sizeof(&a + 1):“跳过一整个数组后……4*4。”

【问题与改正】

&a + 1 的确表示整个数组之后的尾后位置,但它仍然是一个指针表达式。因此 sizeof 结果是 P,不是 16。

“加一跳过多少字节”与“指针类型自身占几字节”是不同问题。

这里加一的步长是 16 字节,但 sizeof 这个指针表达式,通常仍是 4 或 8 字节。

【运行结果】

在 int 占 4 字节、上述指针占 8 字节的环境中:

16
8
4
8
4
8
16
8
8
8

四、没有结束标记的字符数组

【代码】原文的字符数组(局部示例)

char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};

【文字解释】sizeof 部分

原文表达式正确结果原因
sizeof(arr)6六个 char,没有自动追加 \0
sizeof(arr + 0)P首元素指针
sizeof(*arr)1第一个 char
sizeof(arr[1])1第二个 char
sizeof(&arr)P整个数组的地址,是指针
sizeof(&arr + 1)P整个数组的尾后指针
sizeof(&arr[0] + 1)P第二个字符的地址

【原文】把 arr[1] 解释成“首元素”。

【改正】它是第二个元素 'b';大小仍然是 1,所以数值结论不变。

【问题】
缺少结束标记不是“合法返回一个随机长度”。

本例在数组有效范围内没有 \0,strlen 会尝试读过数组边界,产生未定义行为,可能看似输出某个数,也可能崩溃,不能保证结果。

【改正】逐项标记原文表达式

原文表达式正确判断
strlen(arr)缺少结束标记,不能合法统计,未定义行为
strlen(arr + 0)同上
strlen(*arr)*arr 是 char,不是字符串指针;参数类型错误
strlen(arr[1])arr[1] 是 char,也不是字符串指针
strlen(&arr)参数是 char (*)[6],与要求的字符指针类型不匹配;数组也没有结束标记
strlen(&arr + 1)类型不匹配,并且是数组尾后位置,不能把它当成可读字符串
strlen(&arr[0] + 1)起点是第二个字符,但剩余范围也没有结束标记,未定义行为

原文把 strlen(*arr) 与 strlen(arr[1]) 都联系到字符编码 97,也不准确:

  • 在 ASCII 环境中,前者的字符是 'a',编码 97。
  • 后者是 'b',编码 98。

但这两个数都不是 strlen 的合法实参。

类型不匹配应由编译器诊断;强行接受错误调用,也不能据此推导固定输出。

【运行结果】

sizeof 的结果可按表确定;上述错误 strlen 调用不提供运行结果,不执行它们来“验证随机值”。

五、带结束标记的字符数组

【代码 3】保留原文数据并运行合法表达式(完整程序)

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

int main(void)
{
    char arr[] = "abcdef";

    printf("%lu\n", (unsigned long)sizeof(arr));
    printf("%lu\n", (unsigned long)sizeof(arr + 0));
    printf("%lu\n", (unsigned long)sizeof(*arr));
    printf("%lu\n", (unsigned long)sizeof(arr[1]));
    printf("%lu\n", (unsigned long)sizeof(&arr));
    printf("%lu\n", (unsigned long)sizeof(&arr + 1));
    printf("%lu\n", (unsigned long)sizeof(&arr[0] + 1));

    printf("%lu\n", (unsigned long)strlen(arr));
    printf("%lu\n", (unsigned long)strlen(arr + 0));
    printf("%lu\n", (unsigned long)strlen(&arr[0] + 1));

    return 0;
}

【文字解释】sizeof 部分

表达式结果
sizeof(arr)7,含末尾 \0
sizeof(arr + 0)P
sizeof(*arr)1
sizeof(arr[1])1
sizeof(&arr)P
sizeof(&arr + 1)P
sizeof(&arr[0] + 1)P

【原文与纠正】strlen 部分

原文表达式及说法正确判断
strlen(arr),结果 6正确,从 a 数到结束标记之前
strlen(arr + 0),同上正确,起点没变,结果 6
strlen(*arr),a 的 ASCII 值 97参数类型错误;97 不是 strlen 的结果
strlen(arr[1]),b 的 ASCII 值 98参数类型错误;98 不是 strlen 的结果
strlen(&arr),“同 2、3”char (*)[7] 与要求的类型不匹配;要读取原字符串,使用 strlen(arr)
strlen(&arr + 1),“下一个数组、随机值”类型不匹配且指向尾后;不能假定后面存在另一个数组或字符串
strlen(&arr[0] + 1),“同 2、3”起点变成 b,结果应是 5,不是 6

&arr 与 arr 的起始存储位置对应,但类型不同,不能据此认定它们在所有函数实参位置都能互换。

【运行结果】

在上述指针占 8 字节的环境中:

7
8
1
1
8
8
8
6
6
5

六、字符指针变量的 sizeof 与 strlen

【代码 4】保留原文的字符指针定义(完整程序)

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

int main(void)
{
    char *p = "abcdef";

    printf("%lu\n", (unsigned long)sizeof(p));
    printf("%lu\n", (unsigned long)sizeof(p + 1));
    printf("%lu\n", (unsigned long)sizeof(*p));
    printf("%lu\n", (unsigned long)sizeof(p[0]));
    printf("%lu\n", (unsigned long)sizeof(&p));
    printf("%lu\n", (unsigned long)sizeof(&p + 1));
    printf("%lu\n", (unsigned long)sizeof(&p[0] + 1));

    printf("%lu\n", (unsigned long)strlen(p));
    printf("%lu\n", (unsigned long)strlen(p + 1));
    printf("%lu\n", (unsigned long)strlen(&p[0] + 1));

    return 0;
}

【文字解释】

保留:

char *p = "abcdef";

因为这是合法的 C 写法;但不能通过 p 修改字符串字面量。

若希望类型明确表达只读意图,可以另写成 const char *p,本篇没有悄悄替换原定义。

sizeof 表达式操作数类型结果
sizeof(p)char 指针P
sizeof(p + 1)char 指针P
sizeof(*p)char1
sizeof(p[0])char1
sizeof(&p)指向 char 指针变量的指针,即 char **P
sizeof(&p + 1)char **P
sizeof(&p[0] + 1)char 指针P

p + 1 指向字符 b;&p + 1 则是越过指针变量 p 自身的尾后位置,二者不是同一个意思。

【问题与改正】

应记住的是:

p[i] 等价于 *(p + i)

不是 *p + i。

写法含义
*(p + i)先移动指针,再读取那个位置的字符
*p + i先读取第一个字符,再对字符编码值加 i

原文在两处写了这个等式,两处都需要改正。

某些连续字母的编码可能让结果偶然相同,但规则不同。

【原文与纠正】strlen 部分

原文表达式正确判断
strlen(p)6,字符个数,不是计算指针自身的大小
strlen(p + 1)5,从 b 开始
strlen(*p)char 实参,不是字符指针,类型错误
strlen(p[0])同上
strlen(&p)char **,不是要求的字符指针;不能写成“随机值”
strlen(&p + 1)char ** 类型不匹配,并且是指针变量尾后位置
strlen(&p[0] + 1)5,原文结论正确

原文把长度写成“61”“51”,在本例中数值碰巧相同,但 strlen 的含义应写成“6 个字符”“5 个字符”,避免与 sizeof 的字节数混淆。

【运行结果】

在本例相关指针都占 8 字节的环境中:

8
8
1
1
8
8
8
6
5
5

七、二维数组的 sizeof

【代码 5】保留原文的二维数组表达式(完整程序)

#include <stdio.h>

int main(void)
{
    int a[3][4] = {0};

    printf("%lu\n", (unsigned long)sizeof(a));
    printf("%lu\n", (unsigned long)sizeof(a[0][0]));
    printf("%lu\n", (unsigned long)sizeof(a[0]));
    printf("%lu\n", (unsigned long)sizeof(a[0] + 1));
    printf("%lu\n", (unsigned long)sizeof(*(a[0] + 1)));
    printf("%lu\n", (unsigned long)sizeof(a + 1));
    printf("%lu\n", (unsigned long)sizeof(*(a + 1)));
    printf("%lu\n", (unsigned long)sizeof(&a[0] + 1));
    printf("%lu\n", (unsigned long)sizeof(*(&a[0] + 1)));
    printf("%lu\n", (unsigned long)sizeof(*a));
    printf("%lu\n", (unsigned long)sizeof(a[3]));

    return 0;
}

【文字解释与结果】

原文表达式操作数类型或含义结果
sizeof(a)三行四列的整个数组48
sizeof(a[0][0])一个 int4
sizeof(a[0])第一行,含 4 个 int16
sizeof(a[0] + 1)第一行第二个整数的地址P
sizeof(*(a[0] + 1))一个 int4
sizeof(a + 1)第二行的地址,类型 int (*)[4]P
sizeof(*(a + 1))第二行数组16
sizeof(&a[0] + 1)第二行数组的地址P
sizeof(*(&a[0] + 1))第二行数组16
sizeof(*a)第一行数组16
sizeof(a[3])操作数类型是 int[4],不求值16

原文对 sizeof(a[3]) 的数值判断可以保留。

这个固定长度数组只有下标 0、1、2 三行,但这里 sizeof 不实际求值,不读取第四行的数据。

【限定说明】不能因此写成“访问 a[3] 永远没问题”;这里仅讨论 sizeof 中未求值的固定类型表达式。

C99 及以后变长数组相关的 sizeof 有额外规则,本篇 C89 示例不涉及。

【运行结果】

在 int 占 4 字节、相关指针占 8 字节的环境中:

48
4
16
8
4
8
16
8
16
16
16

八、原文“数组名的意义”需要怎样限定

【原文】

  1. sizeof(数组名) 表示整个数组。
  2. &数组名取得整个数组的地址。
  3. 除此之外所有数组名都表示首元素地址。

【问题与改正】

对当前常见练习,可以重点记住前两种例外,但第三条不要写成没有例外的绝对规则。

更准确的说法是:

数组类型表达式在多数表达式中转换为指向首元素的指针;作为 sizeof 或一元 & 的直接操作数时,不发生这种转换。

字符串字面量用于初始化字符数组也有特殊规则。

此外,函数形参:

int arr[]

已经调整为指针类型,函数里的 sizeof(arr) 不能再按调用者的整个数组求大小。

数组名也不是一个另外创建出来、里面存着地址的指针变量;数组对象保存元素,使用数组表达式时再按语境决定是否发生转换。

九、截图练习:整个数组地址加一

【原文代码】保留供分析

int a[5] = {1, 2, 3, 4, 5};
int *ptr = (int *)(&a + 1);

printf("%d,%d", *(a + 1), *(ptr - 1));

【文字解释】

截图按常见课堂地址模型给出的结果是 2,5:

  • a + 1 指向第二个整数。
  • &a + 1 跳过整个数组,再按 int 指针向前移动一个元素。

课堂上用这个例子说明数组指针与元素指针步长不同。

【需要补充的严谨性说明】

不要把“强制转换后的地址位置看起来正确”当成所有后续指针运算都自动受标准保证。

若目的是取得数组元素的合法尾后指针,直接使用 a + 5 更清楚,也不需要跨指针类型转换。

【改正代码 6】明确取得元素尾后指针(完整程序)

#include <stdio.h>

int main(void)
{
    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = a + 5;

    printf("%d,%d\n", *(a + 1), *(ptr - 1));

    return 0;
}

【修改说明】只把 ptr 的初始化改成同一元素数组的尾后指针,保留数据、访问目标和输出目的。

【运行结果】

2,5

十、截图练习:结构体指针与整数加一

【原文代码】仅供题目分析

struct Test
{
    int Num;
    char *pcName;
    short sDate;
    char cha[2];
    short sBa[4];
} *p = (struct Test *)0x100000;

/* 以下为原题表达式,不作为可移植程序运行 */
/* printf("%p\n", p + 0x1); */
/* printf("%p\n", (unsigned long)p + 0x1); */
/* printf("%p\n", (unsigned int *)p + 0x1); */

【文字解释】

原题想比较三个不同的“加一”:

表达式原题意图
p + 1按 struct Test 的大小移动
(unsigned long)p + 1先转换成整数,再做整数加一
(unsigned int *)p + 1按 unsigned int 的大小移动

若题目明确假设:

  • 32 位常见布局。
  • 结构体大小为 20 字节。
  • unsigned int 占 4 字节。
  • 采用平坦地址算术模型。

则预期地址数值分别为:

0x100014
0x100001
0x100004

【问题与改正】

  1. 结构体不一定总是 20 字节,指针大小与对齐方式会影响结果。
  2. 将整数 0x100000 转成指针,并没有创建一个真实数组对象,不能据此认定后续指针加法是可移植的合法操作。
  3. (unsigned long)p + 1 是整数表达式,不能用 %p 输出;unsigned long 也不一定能容纳指针转换结果。
  4. %p 输出对象指针时,应传入 void *。它不是“把任意整数当作地址打印”的通用格式。

所以,这一题应标记为“带环境假设的地址运算练习”,不能作为跨平台保证的运行结果。

十一、截图练习:圆括号里的逗号表达式

【原文代码】保留原题初始化形式(局部示例)

int a[3][2] = {(0, 1), (2, 3), (4, 5)};

【问题与改正】

这里使用的逗号表达式不属于 C89 要求的常量表达式,严格 C89 不接受用它们初始化这个聚合对象。

一些编译器扩展或较新的 C 标准可以接受,因此截图结果需要注明环境,不能直接标成严格 C89 写法。

为保留原题想考查的逗号表达式,下面先把数组置零,再在赋值语句中计算相同的三个表达式;不改变目标元素值。

【代码 7】保留逗号表达式含义的 C89 写法(完整程序)

#include <stdio.h>

int main(void)
{
    int a[3][2] = {0};
    int *p;

    a[0][0] = (0, 1);
    a[0][1] = (2, 3);
    a[1][0] = (4, 5);

    p = a[0];
    printf("%d\n", p[0]);

    return 0;
}

【文字解释】

原题使用的是圆括号,不是表示每行初始化的花括号。

三个逗号表达式的结果分别是 1、3、5。

因此,对应的数组内容是:

行第 0 列第 1 列
013
150
200

没有显式给出的元素补零。

p = a[0] 让 p 指向第一行的第一个整数,p[0] 就是 1。

原文的逗号表达式分析和截图中的这个结果是正确的。“答案是 1”应对应这道题,不能代替其他未指明题目的答案。

【运行结果】

1

十二、截图练习:列数不同的数组指针与指针相减

【原文代码】错误示例,保留供分析

int a[5][5];
int (*p)[4];

/* p = a; */
/* printf("%p, %d\n", */
/*        &p[4][2] - &a[4][2], */
/*        &p[4][2] - &a[4][2]); */

【问题】

a 转换后的类型是:

int (*)[5]

p 的类型是:

int (*)[4]

列数不同,不能直接当成匹配的指针赋值。

原截图按步长算出相差 4 个 int 的位置,得出差值 -4,并尝试用 %p 显示其位模式。

但这个过程不能当成标准 C 保证的输出。

【改正】

指针相减要求两个指针指向同一个数组对象的元素或尾后位置,结果是元素距离,类型为 ptrdiff_t,不是地址。

只说“同一块空间”不够精确。

即使整个二维数组连续存放,也不能把不同行的 int 子数组无条件当成一个大的一维 int 数组来相减。

如果只想演示合法的差值 -4,可以让两个指针指向同一行。

【代码 8】合法演示同一数组内的元素距离(完整程序)

#include <stdio.h>
#include <stddef.h>

int main(void)
{
    int a[5][5] = {0};
    ptrdiff_t distance = &a[4][0] - &a[4][4];

    printf("%ld\n", (long)distance);

    return 0;
}

【修改说明】这是保留原题“-4 的元素距离”教学目的的替代示例,不冒充原错误代码的运行结果。

【运行结果】

-4

十三、截图练习:二维数组两个位置向前移动

【原文代码】保留供分析

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", *(ptr1 - 1), *(ptr2 - 1)); */

【文字解释】

原截图按连续存储的地址模型把结果标为 10,5:

  • ptr1 对应整个二维数组之后的位置。
  • ptr2 指向第二行首元素 6,按地址向前一个 int 会落在第一行末尾的 5。

【需要改正的限制】

*(aa + 1) 就是第二行数组,在这里转换成 int 指针,不需要再强制转换。

它指向第二行首元素;ptr2 - 1 会越过该行子数组的起点,不能因为前一行在内存中相邻就认为它是标准保证的合法运算。

【代码 9】使用明确的行指针取得相同两个数(完整程序)

#include <stdio.h>

int main(void)
{
    int aa[2][5] = {
        {1, 2, 3, 4, 5},
        {6, 7, 8, 9, 10}
    };
    int (*end)[5] = aa + 2;
    int (*second)[5] = aa + 1;

    printf("%d,%d\n", (*(end - 1))[4],
                      (*(second - 1))[4]);

    return 0;
}

【修改说明】改为在外层两行数组中移动行指针,再访问对应行的最后一个元素;数据与两个目标数没有改变。

【运行结果】

10,5

十四、截图练习:字符串指针数组与二级指针

【代码 10】保留原文定义与操作(完整程序)

#include <stdio.h>

int main(void)
{
    char *a[] = {"work", "at", "alibaba"};
    char **pa = a;

    pa++;
    printf("%s\n", *pa);

    return 0;
}

【文字解释】

截图中的结论 at 正确。

a 是含有 3 个 char * 元素的指针数组,不是一级指针变量。

pa 是二级指针变量。初始化时 a 转换为首元素指针,pa 指向 a[0] 这个指针元素。

执行过程是:

  1. pa++ 跳过一个 char * 元素,到达 a[1]。
  2. *pa 取得 a[1] 保存的字符地址。
  3. %s 从这个地址开始打印字符串,得到 at。

这里 pa 加一的步长是 sizeof(char *),不是一个字符,也不是把字符串 work 跳过去。

【运行结果】

at

十五、截图练习:三级指针逐句分析

【原文需要核对之处】

截图初始化行看起来写成:

"POINT""FIRST"

两者之间没有逗号。

如果按这个写法照抄,相邻字符串字面量会拼接成 "POINTFIRST",并不是原图后面分析的两个独立字符串。

【改正】

根据后面四个指针目标和输出分析,应明确补上逗号:

"POINT", "FIRST"

这是影响实际数组元素个数的修改,不能只当排版忽略。

【代码 11】补全逗号并保留原题四条输出(完整程序)

#include <stdio.h>

int main(void)
{
    char *c[] = {"ENTER", "NEW", "POINT", "FIRST"};
    char **cp[4];
    char ***cpp = cp;

    cp[0] = c + 3;
    cp[1] = c + 2;
    cp[2] = c + 1;
    cp[3] = c;

    printf("%s\n", **++cpp);
    printf("%s\n", *--*++cpp + 3);
    printf("%s\n", *cpp[-2] + 3);
    printf("%s\n", cpp[-1][-1] + 1);

    return 0;
}

【修改说明】

原图使用:

char **cp[] = {c + 3, c + 2, c + 1, c};

为满足严格 C89 对局部聚合初始化的要求,这里改成声明后逐项赋值,保存的四个地址和后续操作不变。

【文字解释】初始状态

对象保存的内容
c[0]ENTER 首字符地址
c[1]NEW 首字符地址
c[2]POINT 首字符地址
c[3]FIRST 首字符地址
cp[0]c + 3
cp[1]c + 2
cp[2]c + 1
cp[3]c
cpp指向 cp[0]

第一条:

**++cpp

先让 cpp 移到 cp[1];一次解引用得到 c + 2,再解引用得到 POINT 的首字符地址,输出 POINT。

第二条:

*--*++cpp + 3

执行过程:

  1. 先让 cpp 移到 cp[2]。
  2. *cpp 就是 cp[2],原来保存 c + 1。
  3. 前置 -- 把这个指针元素改成 c。
  4. 再解引用得到 ENTER 的首字符地址。
  5. 加 3 后从第四个字符 E 开始打印,输出 ER。

注意:这条语句除了移动 cpp,还改变了 cp[2] 保存的地址,但没有修改字符串字面量。

第三条:

*cpp[-2] + 3

当前 cpp 指向 cp[2],所以 cpp[-2] 是 cp[0],保存 c + 3。

解引用得到 FIRST 的首字符地址,加 3 后输出 ST。

第四条:

cpp[-1][-1] + 1

cpp[-1] 是 cp[1],保存 c + 2;再偏移 -1 并取元素,取得 c[1] 保存的 NEW 首字符地址。

最后加 1,从 E 开始输出 EW。

负下标并非一律错误:

p[-1] 等价于 *(p - 1)

关键看移动后是否仍在对应数组的合法范围内。这道题中的相关访问都可在各自数组内解释。

【运行结果】

POINT
ER
ST
EW

原截图后面四条输出的分析,在明确使用四个字符串的前提下是正确的。

参考核对:C 标准委员会草案 N1570 中 sizeof、指针加减、strlen 的规则,分别见 6.5.3.4、6.5.6、7.24.6.3。

原文中类型错误或依赖环境的片段与可运行纠正程序已分别标注。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/qiu20071217/article/details/169849882

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--