[特殊字符]函数指针：C语言的动态灵魂，嵌入式的超能力（202589)

最新推荐文章于 2026-06-20 16:52:53 发布
原创 最新推荐文章于 2026-06-20 16:52:53 发布 · 870 阅读 · 16 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c语言 #开发语言

ccc函数指针：C语言的动态调度灵魂🌶️，嵌入式的超能力

参考教程::C函数指针;


//相当于`“策略模式”

一、函数指针定义

//基本形式：返回类型（*指针名）（参数列表）
                 int (*MathOperations)(int , int);

二、函数指针的四大应用场景

2.1、📋 回调机制（异步通信的基石）
#include <iostream>
#include <cstring>

using namespace std;

//typedef定义HandleDataCallBack函数指针类型，用于实现“回调机制”
typedef void (*HandleDataCallBack)(const char *ptData, unsigned int size);   

// 跨平台字符串复制实现
size_t GetDataInfo(char* buffer) {
    const char* testData = "Hello CallBack";
    size_t len = strlen(testData);
    
    // 添加边界检查
    if (len >= 1024) len = 1023;  // 防止缓冲区溢出
    
    // 跨平台安全复制
    #ifdef _WIN32
        // Windows 安全版本
        strncpy_s(buffer, 1024, testData, len);
    #else
        // Linux/Unix 标准版本
        strncpy(buffer, testData, len);
    #endif
    
    buffer[len] = '\0';  // 确保字符串以 null 结尾
    return len;
}

// 数据接收函数
void DataRecv(HandleDataCallBack dataHandle) {      //HandleDataCallBack dataHandle
    char buf[1024] = {0};
    
    size_t actualSize = GetDataInfo(buf);
    
    if (dataHandle && actualSize > 0 && actualSize <= UINT_MAX) {
        dataHandle(buf, static_cast<unsigned int>(actualSize));
    }
}

void ProcessData(const char *ptData, unsigned int size) {
    if (!ptData || size == 0) return;
    cout << "Received data: " << ptData << " (size: " << size << ")" << endl;
}

int main() {
    cout << "=============== CallBack Function Show Start===============" << endl;
    DataRecv(ProcessData);
    cout << "=============== CallBack Function Show End===============" << endl;
    return 0;
}

💡 总结：核心设计模式

这段代码完美展示了 回调函数模式 的应用：

  • 解耦 ：数据接收和数据处理逻辑分离
  • 灵活性 ：可以动态更换不同的处理函数
  • 可扩展性 ：易于添加新的数据处理逻辑

2.2、📋 策略模式（运行时的算法切换）

核心思想是把“算法”抽象成一个函数指针，然后在运行时根据 AlgoBitsFlag 的值动态地切换具体排序算法

// 排序算法接口
typedef void (*SortAlgo)(int *ptArr, int size);

// 冒泡排序
void BubbleSort(int *ptArr, int size) { /* bubble sort */ };
// 插入排序
void InsertSort(int *ptArr, int size) { /* Insert sort */ };
// 快速排序
void QuickSort(int *ptArr, int size) { /* Quick sort */ };
// 希尔排序
void ShellSort(int *ptArr, int size) { /* Shell sort */ };
// 选择排序
void SelectSort(int *ptArr, int size) { /* Select sort */ };

int AlgoBitsFlag = 0x0;

// 执行排序
void ExecuteSort(SortAlgo algo, int *ptArr, int size)
{
    if (!ptArr || !size)
        return;

    algo(ptArr, size);
}

int main()
{
    SortAlgo algo;
    int data[1024] = {0};

    // 动态选择排序算法
    if (AlgoBitsFlag & 0x1)
        algo = BubbleSort;
    else if (AlgoBitsFlag & 0x10)
        algo = InsertSort;
    else if (AlgoBitsFlag & 0x100)
        algo = QuickSort;
    else if (AlgoBitsFlag & 0x1000)
        algo = ShellSort;
    else if (AlgoBitsFlag & 0x10000)
        algo = SelectSort;
    else
        algo = QuickSort;

    ExecuteSort(algo, data, sizeof(data) / sizeof(data[0]));

    return 0;
}

💡 总结：策略模式（Strategy Pattern），

这段代码完美展示了 策略模式Strategy Pattern 的应用：

  • 开闭原则: 新增排序算法时，只需再写一个函数，把函数指针赋给 algo 即可，无需改动 ExecuteSort 或 main 里的流程代码。
  • 运行时灵活切换: 通过位掩码 AlgoBitsFlag 可以在程序运行期间随时决定用哪种算法，而不需要重新编译。
  • 调用方与算法解耦: ExecuteSort 只关心接口（函数指针），不关心具体实现，降低了模块间的耦合度，方便单元测试和替换实现。

2.3、📋 状态机切换（复杂流程控制）
#include <cstdio>
#include <thread>
#include <chrono>
#include <windows.h>

// 前置声明
void CheckDeviceState();

// 设备状态
typedef void (*DeviceState)(void);

// 空闲态
void IdleState()
{
    printf("********** idle **********\n");
}

// 运行态
void RunningState()
{
    printf("********** Running **********\n");
}

// 故障态
void ErrorState()
{
    printf("********** error **********\n");
}

// 状态机
typedef struct tagTDeviceState
{
    DeviceState state;
} TDeviceState;

int OperationFlag = 0;

// 检查并切换状态
void CheckDeviceState()
{
    TDeviceState current;
    current.state = IdleState;

    for (;;)
    {
        current.state();
        // 简单事件：根据 OperationFlag 切状态
        if (OperationFlag == 0)
            current.state = RunningState;
        else
            current.state = ErrorState;

        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main()
{
    // 解决中文乱码：把控制台代码页设为 UTF-8
    UINT oldcp = GetConsoleOutputCP();
    SetConsoleOutputCP(65001);

    std::thread worker(CheckDeviceState);
    char cmd;
    while (true)
    {
        printf("\n输入 0 切运行态，输入非 0 切故障态，输入 q 退出：\n");
        std::scanf(" %c", &cmd);

        if (cmd == 'q' || cmd == 'Q')
            break;

        OperationFlag = (cmd == '0') ? 0 : 1;
    }

    // 恢复原来的代码页
    SetConsoleOutputCP(oldcp);

    worker.detach();
    return 0;
}

💡 总结：函数指针状态机

	♦️ 通过函数指针动态切换函数行为，实现状态切换；

	♦️ 使用多线程，实现异步状态检查和用户交互；

2.4、📋 C语言类实现
#include<stdio.h>

// 学生结构体定义
// num: 学号
// score: 分数
// Func: 函数指针，用于指向打印学生信息的函数
typedef struct TStudent{
    int num;
    int score;
    void (*Func)(struct TStudent *);
}TStudent;

// 打印学生信息函数
// ptStudent: 指向学生结构体的指针
void PrintStudent(TStudent *ptStudent){
	if (!ptStudent) return;  // 安全检查
    printf("num = %.5d, score = %d\n", ptStudent->num, ptStudent->score);
}

// 创建学生对象函数
// num: 学号
// score: 分数
// 返回值: 初始化好的学生结构体
TStudent CreatStudent(int num,int score){
    TStudent student = {num,score, PrintStudent };  // 初始化结构体并设置函数指针
    return student;
}

int main(void){
    // 创建学生对象
    TStudent student = CreatStudent(00001,100);
    
    // 通过函数指针调用打印函数
    student.Func(&student);
    
    return 0;
}

💡 总结：当前实现中 PrintStudent 函数作为成员函数指针使用，展示了面向对象思想在C语言中的实现方式

  • 灵活性: 通过函数指针 Func 成员，可以动态绑定不同的函数实现，实现运行时多态；
  • 封装性: 将打印逻辑封装在 PrintStudent 函数中，通过指针调用，使代码更模块化；
  • 简洁性: 通过 student.Func(&student) 一行代码完成打印操作，调用方式直观简洁。

三、函数指针高级技巧

3.1 函数指针数组
#include<stdio.h>

typedef int (*BoradPowerInitFunc)(void);


// 三个独立的功能模块

/**
 * @description: 电源启动
 * @return {*}
 */
int  BoardPowerOn(){
    printf("Power On\n");   // 单一职责原则
    return 0;
}

/**
 * @description: 注册
 * @return {*}
 */
int Register(){
    printf("Register\n");   // 设备注册
    return 0;
}

/**
 * @description: 参数配置
 * @return {*}
 */
int ParaConfig(){
    printf("ParaConfig\n");  // 模块化设计
    return 0; 
}

BoradPowerInitFunc InitTable[]={
    BoardPowerOn,     // 可自由调整顺序
    Register,         // 方便增删模块
    ParaConfig,       // 拓展性强
};

int main(){
    for(int i = 0; i < sizeof(InitTable) / sizeof(InitTable[0]); i++){
        InitTable[i]();
    }
    return 0;
}

💡 总结：通过==函数指针数组实现模块化的初始化流程管理==；

  • 模块化设计：各功能符合单一职责原则；
  • 流程标准化：通过BoradPowerInit实现统一函数签名，确保接口一致性；
  • 集中管理 ：初始化步骤在函数指针数组中显式声明配置，与执行逻辑解耦；

【💻提升：多板初始化配置】

在这里插入图片描述

#include <stdio.h>

typedef int (*BoradPowerInitFunc)(void);

/* 单板初始化配置结构体
 * @成员说明：
 *   BoardName      - 单板硬件名称 
 *   BoardType      - 单板类型编码（0x01~0x03）
 *   BoardStatsus   - 状态寄存器（0xff表示未初始化状态）
 *   BoardPowerInit - 硬件上电初始化入口函数
 *   Register       - 操作系统注册接口
 *   ParaConfig     - 个性化参数配置接口 
 */
typedef struct tagBoardInitConifg{
    const char *BoardName;              
    int BoardType;                      
    int BoardStatsus;                   
    BoradPowerInitFunc BoardPowerInit;  
    int (*Register)(void);              
    int (*ParaConfig)(void);            
}TBoardInitConfig;

// 单板A初始化函数（返回0表示成功）
int BoardA_Init()   
{
    printf("BoardA_Init...\n");
    return 0;
}

// 单板B初始化函数（返回0表示成功）
int BoardB_Init()  
{
    printf("BoardB_Init...\n");  
    return 0;
}

// 单板C初始化函数（返回0xFF表示初始化失败
int BoardC_Init()   
{
    printf("BoardC_Init...\n");  
    return 0xff;
}   


//单板向操作系统注册
int OssRegister(){
    printf("OssRegister\n");
    return 0;
}

int BoardA_ParaCfg(){
    printf("BoardA_Register\n");
    return 0;
}

int BoardB_ParaCfg(){
    printf("BoardB_Register\n");
    return 0; 
}

int BoardC_ParaCfg(){
   printf("BoardC_Register\n"); 
   return 0; 
}

//✨板初始化表
TBoardInitConfig BoardInitTable[] = {
// 参数说明：名称 | 类型 | 状态 | 初始化函数 | 注册接口 | 配置接口
     {"Board_A", 0x01, 0xff, BoardA_Init, OssRegister, BoardA_ParaCfg},
     {"Board_B", 0x02, 0xff, BoardB_Init, OssRegister, BoardB_ParaCfg}, 
     {"Board_C", 0x03, 0xff, BoardC_Init, OssRegister, BoardC_ParaCfg},
     {NULL, 0xff, 0xff, NULL, NULL, NULL}   // 结束标记
};

int main(){
    TBoardInitConfig *pBoardInitTable = BoardInitTable;
    /* 初始化流程控制逻辑
     * 1. 遍历所有单板配置
     * 2. 执行三级初始化流程：
     *    - 电源初始化 → 信息打印 → 注册 → 参数配置
     * 3. 支持初始化失败处理（当前仅跳过失败单板） */

    while(pBoardInitTable->BoardName != NULL){
        int result = pBoardInitTable->BoardPowerInit();   // 执行单板上电初始化

        if(result == 0x0){
            printf("Board %s Init Success, Result Code: 0x%x\n", pBoardInitTable->BoardName, result); 

            // 打印单板基础信息
            printf("Board Name:   %s\n", pBoardInitTable->BoardName);  
            printf("Board Type:   %d\n", pBoardInitTable->BoardType);
            printf("Board Status: 0x%x\n", pBoardInitTable->BoardStatsus); 
            // 执行后续初始化步骤
            pBoardInitTable->Register();
            pBoardInitTable->ParaConfig();
            printf("\n");
        }else{
            printf("Board %s Init Failed, Result Code: 0x%x\n", pBoardInitTable->BoardName, result);
            printf("\n"); 
        }
        pBoardInitTable++;  // 指针移动到下一个单板配置
    }
    return 0;
}

3.2 返回函数指针的函数
#include <stdio.h>

// 定义函数指针类型，用于统一接口的数学运算操作
typedef int(*Operation)(int, int);

int add(int a, int b){ return a + b; }
int subtract(int a, int b){ return a - b; }
int multiply(int a, int b){ return a * b; }
int divide(int a, int b){ return a / b ? : a / b , 0; }

// 工厂函数：根据操作符返回对应的运算函数
Operation CalcResult(char ch){
    switch(ch){
        case '+': return add;
        case '-': return subtract;
        case '*': return multiply;
        case '/': return divide;
        default: return NULL;
    }
}

int main(){
    Operation op = CalcResult('+');    //返回函数指针
    if(op){
        int result = op(10, 5);
        printf("Result: %d\n", result); 
    }    
    return 0;
}

💡 总结：简单工厂模式

  • 接口抽象化：通过Operation函数指针类型统一了所有算术操作的调用接口，符合面向接口编程思想
  • 开闭原则：新增运算操作只需添加函数实现和case分支，无需修改现有代码（如扩展取模运算）
  • 解耦设计：业务逻辑（main）与具体运算实现分离，CalcResult作为工厂方法隔离了对象创建细节
  • 类型安全：使用typedef明确定义函数指针类型，增强代码可读性和类型安全性
  • 防御式编程：main函数中检查空指针，避免无效操作符导致的运行时错误
  • 可扩展性：运算函数都是无状态纯函数，方便后续扩展为多线程/分布式计算
  • 代码复用：相同调用方式处理不同运算，减少重复代码（如后续添加更多运算符时）
  • 维护友好：每个运算函数保持独立，方便单独测试和修改实现细节

四、性能分析

结论✨：函数指针与直接调用函数方式的**开销差距较小，但架构优势明显**

C/C++ 数据结构（九）深搜广搜
2301_80252792的博客
06-17 575
本文系统介绍了迷宫寻路算法的核心实现方法。重点分析了深度优先搜索(DFS)和广度优先搜索(BFS)两种算法，分别基于栈和队列实现。DFS采用"一条路走到底"的策略，适用于快速找到可行路径；BFS通过分层扩散确保找到最短路径。文章详细展示了两种算法的代码实现，包括迷宫表示、移动方向处理、越界判断等关键环节。同时探讨了路径记录、拾取所有金币等拓展场景，并比较了两种算法在时间复杂度、空间复杂度和适用场景上的差异。最后简要提及了A*算法等进阶内容，为游戏开发和路径规划提供了实用指导。
C语言线程API列表
万法若空
06-20 196
pthread库提供了完整的POSIX线程API，主要分为线程管理（创建/终止/控制）、同步机制（互斥锁/条件变量/读写锁/屏障/自旋锁）、线程特定数据、清理处理程序和属性对象等类别。其中线程管理API包括pthread_create、pthread_join等核心函数；同步机制包含保护临界区的互斥锁、线程协调的条件变量等；属性对象则用于配置线程及同步对象的行为特征。所有pthread标识符均以"pthread_"为前缀，使用时需链接pthread库。这些API共同构成了多线程编程的基础
C语言线程属性(pthread_attr_t)
万法若空
06-20 361
摘要： pthread_attr_t 是 POSIX 线程库中用于配置线程属性的不透明数据类型，通过专用函数进行初始化和设置，确保线程行为的可移植性和可控性。主要属性包括：分离状态（控制资源回收方式）、栈大小（调整线程内存占用）、栈地址（指定栈内存位置）及调度策略（实时系统优先级设置）。使用时需遵循初始化→设置→创建线程→销毁的流程，典型应用如创建分离线程（PTHREAD_CREATE_DETACHED）以自动回收资源。默认属性通常足够，仅在需要精细控制（如实时调度或栈管理）时使用属性对象。
离线数仓开发基础，开发语言（Hive SQL，Shell、Python），开发环境隔离，完整开发流程（面试高频追问）
Irene1991的博客
06-19 349
在数据仓库开发中，HiveSQL是核心开发语言，占比达70%以上，主要用于数据清洗、转换和汇总。Shell脚本（15%）用于调度任务封装，Python（10%）处理复杂业务逻辑和质量校验。数仓表数据存储在HDFS上，表结构元数据存放在MySQL等关系型数据库中，通过Hive进行管理。开发与生产环境严格隔离，通常分为开发、测试和生产三层，通过数据库名、HDFS目录和权限控制实现隔离。开发人员在生产环境仅需只读权限（SELECT），数据修复通过调度系统或DBA执行，确保安全可追溯。
易语言源码易语言安全快速关机程序源码
最新发布
06-22
易语言源码易语言安全快速关机程序源码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值