学习记录:露露同学的 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
| 对比项 | sizeof | strlen |
|---|---|---|
| 本身是什么 | 运算符 | 库函数 |
| 关注什么 | 类型对应的对象大小 | 字符串结束标记前的字符数 |
是否计算结尾的 \0 | 若它是字符数组元素,会计入整个数组大小 | 不计入长度 |
| 是否读取字符内容 | 本篇固定类型示例不读取操作数的值 | 需要读取字符序列 |
| 是否知道数组容量 | 对完整数组操作数可以得到整个数组大小 | 不知道容量,要求传入有效字符串 |
【代码】原文三个初始化示例(局部示例)
char arr1[] = "abc";
char arr2[3] = "abc";
char arr3[4] = "abc";
【文字解释】
| 定义 | 实际元素 | sizeof 结果 | 能否直接用于 strlen |
|---|---|---|---|
char arr1[] = "abc"; | a、b、c、\0 | 4 | 可以,长度 3 |
char arr2[3] = "abc"; | a、b、c | 3 | 不可以,缺少结束标记 |
char arr3[4] = "abc"; | a、b、c、\0 | 4 | 可以,长度 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 的操作数是什么类型 | 结果 |
|---|---|---|---|
| 1 | sizeof(a) | 含 4 个 int 的数组 | 16 |
| 2 | sizeof(a + 0) | int 指针 | P |
| 3 | sizeof(*a) | int | 4 |
| 4 | sizeof(a + 1) | int 指针 | P |
| 5 | sizeof(a[1]) | int | 4 |
| 6 | sizeof(&a) | 指向整个数组的指针 | P |
| 7 | sizeof(*&a) | 含 4 个 int 的数组 | 16 |
| 8 | sizeof(&a + 1) | 指向数组的指针 | P |
| 9 | sizeof(&a[0]) | int 指针 | P |
| 10 | sizeof(&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) | char | 1 |
sizeof(p[0]) | char | 1 |
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]) | 一个 int | 4 |
sizeof(a[0]) | 第一行,含 4 个 int | 16 |
sizeof(a[0] + 1) | 第一行第二个整数的地址 | P |
sizeof(*(a[0] + 1)) | 一个 int | 4 |
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
八、原文“数组名的意义”需要怎样限定
【原文】
- sizeof(数组名) 表示整个数组。
- &数组名取得整个数组的地址。
- 除此之外所有数组名都表示首元素地址。
【问题与改正】
对当前常见练习,可以重点记住前两种例外,但第三条不要写成没有例外的绝对规则。
更准确的说法是:
数组类型表达式在多数表达式中转换为指向首元素的指针;作为 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
【问题与改正】
- 结构体不一定总是 20 字节,指针大小与对齐方式会影响结果。
- 将整数 0x100000 转成指针,并没有创建一个真实数组对象,不能据此认定后续指针加法是可移植的合法操作。
(unsigned long)p + 1是整数表达式,不能用%p输出;unsigned long 也不一定能容纳指针转换结果。%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 列 |
|---|---|---|
| 0 | 1 | 3 |
| 1 | 5 | 0 |
| 2 | 0 | 0 |
没有显式给出的元素补零。
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] 这个指针元素。
执行过程是:
pa++跳过一个 char * 元素,到达 a[1]。*pa取得 a[1] 保存的字符地址。%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
执行过程:
- 先让 cpp 移到 cp[2]。
*cpp就是 cp[2],原来保存 c + 1。- 前置
--把这个指针元素改成 c。 - 再解引用得到 ENTER 的首字符地址。
- 加 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




