C语言指针详解（上）：指针变量、函数指针

本篇讲解指针的核心概念与使用方法。关于指针安全（空指针、野指针）和嵌入式实战用法，请看《C语言指针详解（下）》。

一、指针基础

1.1 定义

指针变量是一个特殊的变量，它存储的值是另一个变量的内存地址（即地址编号），而不是数据本身。我们平时说的"指针"，通常指的就是这个地址值本身。

语法格式：

数据类型 *指针变量名;

• 数据类型：指针所指向的变量的类型
• *：声明这是一个指针变量
• 指针变量名：指针本身的名字

指针变量的大小是固定的，不取决于它指向什么类型，而取决于系统的地址总线宽度：

// 无论指向什么类型，指针大小都一样（32位系统下均为4）
sizeof(int *)    // 4
sizeof(char *)   // 4
sizeof(double *) // 4
sizeof(void *)   // 4

Visual Studio 2022 x86/x64 系统运行截图：

1.2 基本用法

#include <stdio.h>
#include <stdlib.h>

int b = 20;                          // 全局变量，存在全局/静态区

void main(void)
{
    int a = 10;                      // 局部变量，存在栈区
    int *p1 = &a;                    // p1 → 栈上的 a
    int *p2 = &b;                    // p2 → 全局区的 b
    int *p3 = (int*)malloc(sizeof(int));  // p3 → 堆上动态分配的内存
    if (!p3) {
        return;
    }
    *p3 = 30;

    int *p;
    p = (int *)100;                  // ⚠️ 语法合法，但地址 100 不可读写！

    printf("*p1 = %d, *p2 = %d, *p3 = %d\n", *p1, *(&b), p3[0]);
    printf("p = %p\n", p);
    printf("*p = %d\n", *p);        // ❌ 崩溃！访问了非法地址

    free(p3);
}

这段代码展示了指针的几种典型场景：

1.3 指针访问方式与算术

指针本质就是一个内存地址，通过地址直接读写内存。C 语言提供了三种访问方式，它们的底层都依赖于指针算术。

三种访问方式

方式一：解引用 *p

最基础的访问方式，直接读写指针指向的内存：

int a = 10;
int *p = &a;
*p = 20;       // 写入：a 变为 20
int b = *p;    // 读取：b = 20

方式二：下标 p[n]

p[n] 等价于 *(p + n)，从指针地址偏移 n 个元素后解引用。这就引出了指针算术的核心概念。

方式三：箭头 p->member

用于结构体指针，等价于 (*p).member：

struct Student {
    char name[20];
    int age;
};

struct Student s = {"Tom", 18};
struct Student *p = &s;
p->age = 20;           // 等价于 (*p).age = 20
printf("%s", p->name); // 等价于 (*p).name

指针算术：+1 不是地址 +1

ptr + 1 的核心是「元素个数加 1」，而非「内存地址数值直接加 1 字节」。

公式： 指针偏移后的地址 = 原地址 + n × sizeof(指针指向的类型)

char   *pc = (char *)0x1000;    // pc + 1 → 0x1001  (+1 字节)
int    *pi = (int *)0x1000;     // pi + 1 → 0x1004  (+4 字节)
double *pd = (double *)0x1000;  // pd + 1 → 0x1008  (+8 字节)

实例：数组遍历中的三种访问方式

下面的代码展示了如何用三种等价方式访问数组元素：

int arr[] = {10, 20, 30, 40};
int *p = arr;          // p 指向 arr[0]，假设地址 0x1000

// 指针算术的内存布局：
// p + 0 → 0x1000 → arr[0] = 10
// p + 1 → 0x1004 → arr[1] = 20
// p + 2 → 0x1008 → arr[2] = 30

// 三种等价的访问方式：
printf("%d\n", *(p + 0));  // 方式一：指针算术 + 解引用 → 10
printf("%d\n", p[1]);      // 方式二：下标访问 → 20
printf("%d\n", *(arr + 2));// 方式三：数组名 + 算术 → 30

1.4 指针与数组

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *p = arr;  // 数组名就是首元素的地址

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d, *(p+%d) = %d\n", i, arr[i], i, *(p + i));
    }
    // arr[i] 与 *(p + i) 完全等价

    return 0;
}

数组退化（Array Decay）

上面代码中 int *p = arr 能直接赋值，是因为 C 语言的一条重要规则：数组名在大多数表达式中会自动"退化"为指向首元素的指针。

int arr[5] = {1, 2, 3, 4, 5};

int *p = arr;       // arr 退化成 int*，等价于 &arr[0]

void foo(int *p, int len);
foo(arr, 5);        // 传参时 arr 也会退化成 int*

不退化的三个例外：

void foo(int arr[]) {       // 本质上是 int *arr，已经退化了
    sizeof(arr);            // ⚠️ 得到的是指针大小（4或8），不是数组大小！
}

1.5 指针作为函数参数（传址调用）

#include <stdio.h>

// 通过指针交换两个变量的值
void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    int a = 3, b = 7;
    printf("交换前: a=%d, b=%d\n", a, b);  // a=3, b=7

    swap(&a, &b);  // 传入地址
    printf("交换后: a=%d, b=%d\n", a, b);  // a=7, b=3

    return 0;
}

二、函数指针

2.1 定义与内存视角

在 C 语言中，函数名本质上就是一个地址常量，指向该函数在内存中机器码的入口地址。函数指针是一个变量，它存储了某个函数的入口地址，通过它可以间接调用该函数。

2.2 声明格式

返回值类型 (*指针变量名)(参数类型列表);

2.3 常见声明示例

// 指向 "无参数、无返回值" 函数的指针
void (*p1)(void);

// 指向 "两个int参数、返回int" 函数的指针
int (*p2)(int, int);

// 指向 "一个char*参数、返回void" 函数的指针
void (*p3)(char *);

// 指向 "无参数、返回 uint8_t*" 函数的指针
uint8_t* (*p4)(void);

2.4 使用 typedef 简化声明

// 定义函数指针类型
typedef int (*MathFunc_t)(int, int);

// 用类型名声明变量，简洁清晰
MathFunc_t pAdd = add;
MathFunc_t pSub = sub;

2.5 赋值与调用

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main(void) {
    int (*p)(int, int);  // 声明函数指针

    p = add;             // 赋值：函数名自动退化为函数指针，不需要 &
    printf("10 + 20 = %d\n", p(10, 20));   // 输出: 30

    p = sub;             // 重新指向另一个函数
    printf("10 - 20 = %d\n", p(10, 20));   // 输出: -10

    return 0;
}

p = add;    // add 退化成函数指针 ✅
p = &add;   // 显式取地址，效果一样 ✅

p(10, 20);       // 直接调用（推荐，简洁）
(*p)(10, 20);    // 解引用调用（更显式）

2.6 回调函数（函数指针作为参数）

回调函数是函数指针最核心的应用——将"行为"作为参数传递给另一个函数。

#include <stdio.h>

typedef int (*Operation_t)(int, int);

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 calculate(int a, int b, Operation_t op) {
    return op(a, b);  // 通过函数指针调用传入的函数
}

int main(void) {
    printf("加法: %d\n", calculate(10, 5, add));  // 15
    printf("减法: %d\n", calculate(10, 5, sub));  // 5
    printf("乘法: %d\n", calculate(10, 5, mul));  // 50
    return 0;
}

2.7 函数指针数组

将多个同类型函数组织成数组，用索引来选择调用哪一个：

#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) { return b != 0 ? a / b : 0; }

int main(void) {
    // 函数指针数组
    int (*ops[])(int, int) = { add, sub, mul, divide };
    const char *names[] = { "加", "减", "乘", "除" };

    int a = 20, b = 5;
    for (int i = 0; i < 4; i++) {
        printf("%s法: %d\n", names[i], ops[i](a, b));
    }
    return 0;
}

三、* 星号辨析：定义指针 vs 解引用 vs 乘法

* 在 C 语言中有 三种完全不同的含义，仅靠上下文区分：

判断方法：看 * 左边是什么

        ┌─ 左边是"类型名" → 定义指针
        │     int *p;       // int 是类型 → 定义指针
  * 号 ─┤
        └─ 左边不是类型名 → 表达式中使用
              *p = 10;      // 左边没有类型 → 解引用
              a * b;        // 两边都是变量 → 乘法

最容易混淆的场景

// 场景一：定义时的初始化 —— * 是声明的一部分，不是解引用
int *p = &a;    // 不是 "把 &a 赋给 *p"，而是 "声明 int* 类型的 p，初始化为 &a"

// 场景二：一行定义多个变量 —— * 只跟紧挨着的变量
int *x, y;      // x 是 int*（指针），y 只是 int（不是指针！）
int *x, *y;     // x 和 y 都是 int*（每个都要加 *）

// 场景三：函数参数中
void foo(int *p) { ... }   // 声明：p 是指针参数
foo(&a);                    // 调用时传地址，这里的 & 是取地址

int *p = &a;     →  * 靠着类型（int）→ 声明指针
*p = 10;         →  * 单独跟变量     → 解引用（写入）
x = *p;          →  * 单独跟变量     → 解引用（读取）
c = a * b;       →  * 两边都是值     → 乘法

四、总结

指针分类速查

五、复习题

选择题

1. 在 32 位系统下，以下哪个表达式的值不是 4？

A. sizeof(int *)
B. sizeof(char *)
C. sizeof(int [5])
D. sizeof(void *)

2. 下面代码的输出是什么？

int a = 5;
int *p = &a;
*p = 20;
printf("%d\n", a);

A. 5
B. 20
C. 地址值
D. 编译错误

3. 以下声明中，哪一个是函数指针？

A. int *p(int, int);
B. int (*p)(int, int);
C. int *(p)(int, int);
D. int (p*)(int, int);

4. int *x, y; 这行代码声明了什么？

A. 两个 int 指针
B. 两个 int 变量
C. x 是 int 指针，y 是 int 变量
D. 编译错误

判断题

5. 数组作为函数参数传递后，在函数内部使用 sizeof 仍能得到数组的总大小。（ ）

6. p = add; 和 p = &add; 效果完全相同，因为函数名会自动退化为函数指针。（ ）

编程题

7. 请写出以下代码的运行结果：

int arr[] = {10, 20, 30, 40, 50};
int *p = arr;
printf("%d %d %d\n", *p, *(p+2), p[4]);

8. 使用函数指针和回调函数实现一个 apply 函数，接收一个整型数组、数组长度和一个函数指针，对数组的每个元素执行该函数并打印结果。

延伸阅读

• C语言指针详解（下） — 空指针、野指针、嵌入式实战用法
• 嵌入式开发函数指针使用 — 函数指针的完整实战应用（状态机、命令解析器、驱动抽象）
• C语言指针和结构体 — 指针与结构体的综合使用
• C语言变量 — 变量的存储与生命周期