指针与函数：值传递与引用传递、函数指针、回调函数、指针作为函数参数与返回值、常见错误

在嵌入式C开发中，函数与指针的结合是构建高效、可维护代码的基石。许多看似棘手的系统问题——如内存泄漏、栈溢出、硬件抽象层设计失败——其根源往往在于对“值传递”与“引用传递”的误解，或是对函数指针使用场景的把握不当。本章将深入剖析指针在函数调用链中的角色，从底层内存模型出发，厘清参数传递的本质，并系统讲解函数指针与回调机制在嵌入式驱动、状态机及事件处理中的工程实践。我们将通过对比、案例拆解和错误复盘，帮助您建立一套安全、规范的内存操作思维。

3.1 值传递与引用传递：内存视角的本质差异

核心原理：栈帧与副本机制

C语言中，所有函数参数默认采用值传递。当调用一个函数时，编译器会将实参的值复制一份压入新栈帧中，被调函数操作的是这份副本。对于基本类型（int、char、float），这非常高效且安全。但对于结构体或数组，值传递意味着整个数据块的拷贝，不仅耗时，而且修改无法影响原数据。

引用传递在C中通过指针实现。我们传递的是变量的地址值（一个32位或64位的整数），被调函数通过解引用操作符*访问并修改原内存单元。这避免了大数据拷贝，同时允许函数直接操作调用者的数据。

判断方法：何时选择哪种传递方式

1. 数据大小：若结构体大小超过16字节，优先使用指针传递以避免栈压力。
2. 修改需求：需要修改调用者变量时，必须传指针；若只读，可传const指针。
3. 可空性：指针可以为NULL表示“无数据”，值传递无法表达空状态。

typedef struct {
    uint16_t raw_adc;
    float    voltage;
    uint8_t  status;
} sensor_data_t;

// 错误：值传递导致修改无效且拷贝开销大
void process_sensor_bad(sensor_data_t data) {
    data.voltage = data.raw_adc * 3.3f / 4096.0f;
}

// 正确：指针传递，直接修改原结构体
void process_sensor_good(sensor_data_t *data) {
    if (data == NULL) return;
    data->voltage = data->raw_adc * 3.3f / 4096.0f;
    data->status = (data->voltage > 3.0f) ? 1 : 0;
}

常见误区：混淆数组与指针

数组名在表达式求值时退化为指向首元素的指针，但sizeof操作符除外。许多开发者误以为void func(int arr[])是值传递，实际上它等价于int *arr。这导致在函数内使用sizeof(arr)得到的是指针大小而非数组大小。正确做法是同时传递数组长度参数。

volatile uint32_t g_tick_count;
void timer_isr(void) {
    g_tick_count++;  // 硬件自动保证原子性
}
void read_tick(uint32_t *out) {
    if (out) *out = g_tick_count;  // 读取时建议关中断或使用临界区
}

3.2 函数指针：将代码作为数据操作

核心原理：代码段的地址

函数指针存储的是函数的入口地址，即代码段中的位置。声明方式为返回类型 (*指针名)(参数列表)。在嵌入式领域，函数指针常用于实现状态机跳转表、驱动抽象层和回调机制。

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

// 具体实现
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

// 使用
operation_t op = add;
int result = op(5, 3);  // 通过指针调用

操作流程：安全使用函数指针

1. 初始化：声明时必须初始化，避免野指针。
2. 判空：调用前检查是否为NULL。
3. 类型匹配：参数和返回值必须完全一致。
4. 生命周期：确保函数指针指向的函数在调用时仍然有效（如静态函数或全局函数）。

案例拆解：按键状态机

考虑一个多按键扫描系统，每个按键在不同状态下需要执行不同动作。使用函数指针表可以避免冗长的switch-case。

typedef enum { KEY_IDLE, KEY_PRESSED, KEY_HOLD } key_state_t;
typedef void (*key_action_t)(void);

static void on_press(void) { /* 启动定时器 */ }
static void on_hold(void) { /* 连发处理 */ }
static void on_release(void) { /* 停止定时器 */ }

static const key_action_t action_table[3] = {
    [KEY_IDLE] = NULL,
    [KEY_PRESSED] = on_press,
    [KEY_HOLD] = on_hold
};

void key_process(key_state_t state) {
    if (state < 3 && action_table[state] != NULL) {
        action_table[state]();  // 间接调用
    }
}

此设计将状态与行为解耦，新增状态只需扩展枚举和表项，无需修改核心逻辑。但需注意：函数指针表通常存放在只读区域（Flash），避免被意外修改。

3.3 回调函数：驱动层与业务层的桥梁

核心原理：控制反转

回调函数是一种通过函数指针调用的函数。调用方（通常是底层驱动或框架）在特定事件发生时，调用注册的函数指针。这实现了依赖倒置：底层不依赖具体业务，业务通过注册回调来响应事件。

// 驱动层定义
typedef void (*rx_callback_t)(uint8_t byte);
static rx_callback_t g_rx_cb = NULL;

void uart_register_rx_callback(rx_callback_t cb) {
    g_rx_cb = cb;  // 注册
}

// 中断服务函数中调用
void UART_ISR(void) {
    uint8_t data = UART->DR;
    if (g_rx_cb != NULL) {
        g_rx_cb(data);  // 回调上层
    }
}

// 应用层使用
void my_rx_handler(uint8_t byte) {
    // 处理接收数据
}
void app_init(void) {
    uart_register_rx_callback(my_rx_handler);
}

判断方法：回调的适用场景

• 事件驱动：中断、定时器超时、DMA完成。
• 分层解耦：驱动层不应包含业务逻辑。
• 可扩展性：允许多个模块订阅同一事件（需实现链表管理）。

常见误区：回调上下文与重入

回调函数在中断上下文中执行时，不能调用阻塞函数（如printf、malloc），也不能访问非重入函数。此外，若回调中修改了全局变量，需考虑与主循环的竞争条件。建议在回调中仅做标记或快速处理，将耗时操作推迟到主循环。

3.4 指针作为函数参数与返回值：所有权与生命周期

核心原理：内存所有权的转移

当函数返回指针时，必须明确谁拥有这块内存。常见模式有三种：

1. 返回静态/全局变量地址：线程不安全，但简单。
2. 返回堆内存地址：调用者负责释放，需约定释放函数。
3. 返回传入的指针：常用于链式操作（如memcpy返回目标地址）。

操作流程：安全返回指针的规范

1. 禁止返回局部变量地址：栈帧在函数返回后失效。
2. 堆内存需配对释放：提供create/destroy函数对。
3. 返回NULL表示失败：调用者必须检查。

案例拆解：环形缓冲区设计

一个典型的嵌入式环形缓冲区，其读写函数返回指针或状态码。

typedef struct {
    uint8_t *data;
    uint16_t head;
    uint16_t tail;
    uint16_t size;
} ring_buffer_t;

// 初始化：分配堆内存
int rb_init(ring_buffer_t *rb, uint16_t size) {
    if (rb == NULL || size == 0) return -1;
    rb->data = (uint8_t *)malloc(size);
    if (rb->data == NULL) return -1;
    rb->head = rb->tail = 0;
    rb->size = size;
    return 0;
}

// 写入：返回写入字节数
uint16_t rb_write(ring_buffer_t *rb, const uint8_t *src, uint16_t len) {
    // 实现略
}

// 销毁：释放内存
void rb_destroy(ring_buffer_t *rb) {
    if (rb) {
        free(rb->data);
        rb->data = NULL;
        rb->size = 0;
    }
}

此设计中，rb_init分配内存，rb_destroy释放内存，所有权清晰。调用者必须确保在缓冲区生命周期内不重复初始化或提前销毁。

3.5 常见错误与调试策略

错误清单与根因分析

案例复盘：一次典型的栈溢出故障

背景：某电机控制板在运行数小时后偶发复位。通过查看故障寄存器，发现PC指针指向0x0800_0000（Flash起始），疑似跳转到非法地址。

分析过程：

1. 使用JTAG连接，设置断点在HardFault_Handler，捕获现场。
2. 查看栈指针SP，发现其值超出RAM范围。
3. 回溯调用栈，发现某函数返回了一个局部数组的地址。

根因：

uint8_t *get_packet(void) {
    uint8_t buffer[64];
    // 填充buffer
    return buffer;  // 错误！buffer在栈上，返回后失效
}

解决方案：将buffer改为静态数组或由调用者传入缓冲区。

uint8_t *get_packet(uint8_t *out_buf, uint16_t buf_size) {
    if (out_buf == NULL || buf_size < 64) return NULL;
    // 填充out_buf
    return out_buf;
}

复盘经验：编译器通常会对返回局部变量地址给出警告，但若通过指针间接返回（如memcpy），则不会警告。因此，代码审查时需特别关注返回指针的函数。