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

pstr 这个格子存的是 0x0012ff44,箭头指向只读区域里的 "hello bit.":指针只保存首字符地址,后续字符靠地址连续排列

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] *:数组指针和整个数组的地址是同一类型

(*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]

#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 重名。