const char *pstr = "hello bit."; 看起来像把整串字符装进了指针,实际装进去的只是一个地址:字面量第一个字符 h 的地址。字符串本身放在别处,指针指向它的开头。

64 位平台上,sizeof(pstr) 是 8,sizeof("hello bit.") 是 11,strlen(pstr) 是 10。指针的大小和它指向的内容无关;数组的大小把结尾的 \0 算进去。
char 数组复制内容,char 指针只记地址
#include <stdio.h>
int main(void)
{
char ch = 'w';
char *pc = &ch;
*pc = 'w'; /* 改的是 ch 本身 */
char str1[] = "hello bit."; /* 11 字节的数组,内容可改 */
const char *str2 = "hello bit."; /* 8 字节的指针,指向只读数据 */
str1[0] = 'H'; /* 合法,改自己的副本 */
printf("%s\n", str1); /* Hello bit. */
printf("%s\n", str2); /* hello bit. */
return 0;
}char str1[] = "hello bit."; 在栈上开 11 个字节,把字面量逐字符复制进去,str1 可写。const char *str2 只保存地址,那串字符通常落在只读段,str2[0] = 'H' 是未定义行为。C 里字符串字面量(string literal)的类型是 char[N],不是 const char[N],所以老代码写 char *p = "abc"; 能编译;但它指向的内容仍然不可修改,接口一律用 const char *。
两个内容相同的数组,== 比的是地址
#include <stdio.h>
int main(void)
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
if (str1 == str2)
{
printf("str1 and str2 are same\n");
}
else
{
printf("str1 and str2 are not same\n");
}
if (str3 == str4)
{
printf("str3 and str4 are same\n");
}
else
{
printf("str3 and str4 are not same\n");
}
return 0;
}
str1、str2 是两个独立的数组对象,== 让它们退化成首元素指针,地址不同,结果必然是“不相等”。str3、str4 是两个指针,比较的是里面存的地址;编译器发现两处字面量内容相同,常常只保留一份,于是两个指针指向同一块内存,结果为“相等”。
课件把后半句写成“C/C++ 会把常量字符串存储到单独的一个内存区域,当几个指针指向同一个字符串的时候,他们实际会指向同一块内存”。这是常见实现的做法,不是语言保证。C11 6.4.5 对相同内容的字符串字面量是否互不相同写的是 unspecified:允许合并,也允许各自保留一份。换编译器、换链接选项,str3 == str4 就可能变成 0。
比较内容要用 strcmp,比较“是否指向同一块内存”才用 ==。这两件事在笔试题里经常被混成一件。
int *p1[10] 和 int (*p2)[10]
int *p1[10]; /* 数组,10 个元素,每个是 int * */
int (*p2)[10]; /* 指针,指向一个 int[10] */[] 的优先级高于 *。没有括号时 p1 先和 [10] 结合,所以它是数组;加了括号,p2 先和 * 结合,后面的 [10] 描述它指向的数组有多大。p2 的类型是 int (*)[10],指向的对象是 40 字节的 int[10]。
数组指针只能由整个数组的地址初始化:
#include <stdio.h>
int main(void)
{
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int (*p)[10] = &arr;
printf("%td\n", (char *)(p + 1) - (char *)p); /* 40 */
printf("%d\n", (*p)[3]); /* 4 */
return 0;
}![调试器里 &arr 和 p 的值都是 0x00cffe90,类型都显示为 int[10] *:数组指针和整个数组的地址是同一类型](/images/engineering/c-language/c-pointers-part4/p04-2733x664.webp)
(*p)[3] 先把 p 解引用,拿到它指向的 int[10],再取第 3 个元素。写成 *p[3] 就变了:[] 优先级更高,它等价于 *(p[3]),把 p 当成“指向指针的指针”。int (*p)[10] = arr; 也通不过编译,arr 退化后是 int *,指向一个 int,和 int (*)[10] 不是一回事。
一维场景里 int *p = arr; 就能遍历,数组指针真正的用处是“把一整行当操作单位”。二维数组转置时,形参写成 int (*src)[4]、int (*dst)[3],函数里直接写 dst[j][i] = src[i][j],行内偏移由编译器算。类型绕口时可以起名字:
int arr[3][5] = {0};
typedef int (*rowp_t)[5];
rowp_t p = arr; /* 与 int (*p)[5] = arr; 完全一样 */二维数组的数组名,是第一行的地址
int arr[3][5] 的元素是“一行 int[5]”,数组名退化后是 int (*)[5],指向第一行,不是 int **。
![3 行 5 列的二维数组:每一行是一个 int[5],行与行连续排列,第一行的地址类型就是 int(*)[5]](/images/engineering/c-language/c-pointers-part4/p05-948x395.webp)
#include <stdio.h>
void Print1(int a[3][5], int rows)
{
int i;
int j;
for (i = 0; i < rows; i++)
{
for (j = 0; j < 5; j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
}
void Print2(int (*p)[5], int rows)
{
int i;
int j;
for (i = 0; i < rows; i++)
{
for (j = 0; j < 5; j++)
{
printf("%d ", *(*(p + i) + j));
}
printf("\n");
}
}
int main(void)
{
int arr[3][5] = {{1, 2, 3, 4, 5}, {2, 3, 4, 5, 6}, {3, 4, 5, 6, 7}};
Print1(arr, 3);
Print2(arr, 3);
return 0;
}int a[3][5] 作为形参会被调整成 int (*a)[5],和 int (*p)[5] 是同一个函数类型。第一维写不写、写几都无所谓,第二维的 5 必须保留:编译器算 a[i][j] 的地址要用 基地址 + i × 每行字节数 + j × 4,每行 5 个 int 这个 20 字节是公式的一部分。所以 int a[][5] 合法,int a[3][] 和 int a[][] 都不合法。
*(*(p + i) + j) 就是这条公式的展开:p + i 跳过 i 行,每行 20 字节;*(p + i) 拿到第 i 行的 int[5],它在 [] 语境里退化成 int *;再加 j 解引用,得到元素。
最容易传错的是把二维数组交给 int **:
void wrong(int **p)
{
p[1][0] = 0;
}arr 退化成 int (*)[5],和 int ** 不兼容,编译器会报 incompatible pointer type。真强转过去再跑,p[1] 会从第一行偏移 8 字节处取出 8 个字节当成一个指针去解引用,而那段内存里装的是两个 int,不是地址。int ** 只配指针数组,因为指针数组的每个元素真的是地址。两者看起来都能写两个下标,底层偏移算法完全不同。
函数名和 &函数名 是同一个地址
#include <stdio.h>
#include <stddef.h>
int Add(int x, int y)
{
return x + y;
}
int main(void)
{
printf("Add = %p\n", (void *)(size_t)Add);
printf("&Add = %p\n", (void *)(size_t)&Add);
return 0;
}两次打印的值相同。函数指示符在大多数语境里会转换成“指向函数的指针”,& 只是把这件事写明,不会产生新对象。转换的例外是作为 & 的操作数和作为 sizeof 的操作数。
声明读法还是那套:名字先和右边结合,看它是数组还是函数;再看左边的星号,决定是不是指针。
int (*pf)(int, int) = Add; /* pf 是指针,指向“两个 int 进、一个 int 出”的函数 */
int *fp(int, int); /* fp 是函数,返回 int * */函数指针类型里的参数名可以写也可以省,int (*pf)(int x, int y) 和 int (*pf)(int, int) 是同一个类型;参数名只对阅读有帮助,不参与类型。
两种调用写法都对:pf(2, 3) 和 (*pf)(2, 3) 做同一件事,标准里对函数指针的解引用是可选的装饰。团队里统一一种即可。几个边界要清楚:调用空的函数指针是未定义行为;函数指针不能做加减,函数不是连续对象;ISO C 不保证函数指针和 void * 能互相转换,打印地址时先转成整数再转 void * 只是常见实现的做法。
课件引了两段《C 陷阱与缺陷》里的代码:
(*(void (*)())0)();把整数 0 转成“返回 void、参数未指定”的函数指针,再调用它。这行代码在嵌入式里常被用来跳到固定地址,在普通操作系统上地址 0 不可执行,调用就是未定义行为。读法是从里往外:void (*)() 是函数指针类型,(void (*)())0 是把 0 转成这个类型,最外层的 * 解引用得到函数,末尾的 () 才是调用。
void (*signal(int, void (*)(int)))(int);这是 signal 的声明:参数是一个 int 和一个“接收 int、返回 void”的函数指针,返回值是一个“接收 int、返回 void”的函数指针。用 typedef 可以把它拆开:
typedef void (*pfun_t)(int);
pfun_t signal(int, pfun_t);typedef 给类型起别名,新名字写在 * 的右边:
typedef unsigned int uint;
typedef int *ptr_t;
typedef int (*parr_t)[5]; /* 数组指针类型 */
typedef void (*pfun_t)(int); /* 函数指针类型 */课件把 void (*)() 解释成“无参数的函数指针”,这里要改。C 的声明符里,空括号表示参数未指定,不是“没有参数”;真要无参必须写 (void)。void (*)() 可以接收参数列表任意的函数指针,这正是那段“天书”能在老式 C 里通过的原因。C++ 里空括号表示无参,两门语言在这一处不同。
函数指针数组和转移表
数组能装相同类型的数据,函数指针数组装的就是函数地址:
int (*parr1[3])(int, int); /* 合法:parr1 是数组,3 个元素都是函数指针 */
int *parr2[3](int, int); /* 不合法:数组不能装函数,只能装函数指针 */
int (*)(int, int) parr3[3]; /* 不合法:声明符里没有名字 */parr1 先和 [] 结合,说明它是数组;剩下的 int (*)(int, int) 说明每个元素是什么类型。课件的写法 int (*parr1[3])(); 在 C 里也合法,但参数列表未指定,不如写全 (int, int) 精确。
四个运算照编号放进表,主循环只剩一次下标:
#include <stdio.h>
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }
int divide(int a, int b)
{
if (b == 0)
{
printf("除数不能为 0\n");
return 0;
}
return a / b;
}
void calc(int (*op)(int, int))
{
int x;
int y;
printf("输入操作数:");
if (scanf("%d %d", &x, &y) != 2)
{
printf("输入格式错误\n");
return;
}
printf("ret = %d\n", op(x, y));
}
int main(void)
{
int (*table[5])(int, int) = {NULL, add, sub, mul, divide};
int input = 1;
while (input != 0)
{
printf("1:add 2:sub 3:mul 4:div 0:exit\n请选择:");
if (scanf("%d", &input) != 1)
{
break;
}
if (input >= 1 && input <= 4) /* 范围检查必须在查表之前 */
{
calc(table[input]);
}
else if (input == 0)
{
printf("退出\n");
}
else
{
printf("输入有误\n");
}
}
return 0;
}输入 3 再输入 8 2,输出 ret = 16。和 switch 版本相比,读入、调用、打印只写一份,switch 换成了一张表。新增一个取模,只需写一个函数、在表里加一项,主循环不动。命令分发、中断向量表、状态机,都是“用编号查到函数再调用”这同一个套路;这种按编号索引函数地址的表也叫转移表(jump table)。
查表前那句范围判断不能省。table[99] 读到的是数组之外的随机内存,把那个值当函数指针调用,后果比打印“输入有误”严重得多。表长用 sizeof(table) / sizeof(table[0]) 推出来,增删表项时不用同步改数字。
课件的 div 没有检查除数为 0,用户输入 0 做除数就是整数除零,未定义行为,常见结果是程序直接崩。上面的版本补了判断。命名也换成了 divide,避免和 <stdlib.h> 里的 div 重名。
还没有评论 — 第一条由你来留。