C语言-设计模式

已于 2024-04-01 01:01:59 修改
阅读量1.1k 收藏 30
点赞数 23
分类专栏： C/C++ 设计模式 文章标签： c语言 设计模式
于 2024-03-14 16:11:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19343801/article/details/136713398
版权

模块化编程：

单片机程序往往包含多个功能模块，例如传感器采集、数据处理、通信等。将每个功能模块拆分成独立的模块，利用函数或模块化编程方法来组织代码，有助于提高代码的可维护性和可重用性。

例如，将传感器采集、数据处理和通信功能分别封装成独立的函数或模块，每个模块负责完成特定的功能，以实现清晰的代码结构和分工。

// 传感器采集模块

// 假设传感器采集函数
int read_temperature() {
    // 这里模拟从传感器中读取温度数据
    int temperature = 25; // 假设温度为25摄氏度
    return temperature;
}



// 通信模块

// 假设串口发送函数
void send_data(int data) {
    // 这里模拟通过串口发送数据
    printf("发送数据：%d\n", data);
}



// 主程序

#include <stdio.h>

// 包含传感器采集模块和通信模块的头文件
#include "sensor_module.h"
#include "communication_module.h"

int main() {
    // 读取温度数据
    int temperature = read_temperature();
    printf("当前温度：%d摄氏度\n", temperature);

    // 发送温度数据
    send_data(temperature);

    return 0;
}

状态机：

使用状态机模式来管理系统的状态和状态转换，适用于处理复杂的状态逻辑，例如控制系统、通信协议等。

状态机是一种常见的编程模型，用于描述系统的各种状态以及状态之间的转换规则。在单片机开发中，状态机通常用于管理系统的状态和控制逻辑，例如控制系统、通信协议等。以下是一个简单的状态机示例，演示了如何在单片机开发中应用状态机：

假设我们正在开发一个简单的交通信号灯控制系统，有三种状态：红灯、绿灯和黄灯。根据交通信号灯的状态，系统会采取不同的控制行为。

// 定义交通信号灯的状态枚举
typedef enum {
    RED,
    GREEN,
    YELLOW
} TrafficLightState;

// 定义交通信号灯控制函数
void control_traffic_light(TrafficLightState *state) {
    // 根据当前状态执行相应的控制行为
    switch (*state) {
        case RED:
            printf("红灯亮，停车等待\n");
            // 红灯持续一定时间后切换到绿灯
            delay(5000); // 假设红灯持续5秒
            *state = GREEN;
            break;
        case GREEN:
            printf("绿灯亮，可以通行\n");
            // 绿灯持续一定时间后切换到黄灯
            delay(5000); // 假设绿灯持续5秒
            *state = YELLOW;
            break;
        case YELLOW:
            printf("黄灯亮，请减速慢行\n");
            // 黄灯持续一定时间后切换到红灯
            delay(2000); // 假设黄灯持续2秒
            *state = RED;
            break;
    }
}

int main() {
    TrafficLightState state = RED; // 初始状态为红灯
    while (1) {
        // 控制交通信号灯
        control_traffic_light(&state);
    }
    return 0;
}

中断服务程序（ISR）：

利用中断服务程序来响应外部事件，提高系统的响应速度和实时性。

中断服务程序（ISR）是在单片机系统中用来处理硬件中断的一段特殊的代码。当单片机接收到外部事件或者触发了某个硬件条件时，会中断正在执行的程序，转而执行ISR中的代码，以响应和处理这个中断事件。

以下是一个简单的示例，演示了如何在单片机开发中编写和使用中断服务程序（ISR）：

假设我们正在开发一个基于单片机的计时器系统，当定时器溢出时会触发中断，并执行相应的中断服务程序来处理这个事件。

#include <avr/io.h>
#include <avr/interrupt.h>

// 定义定时器溢出中断服务程序（ISR）
ISR(TIMER1_OVF_vect) {
    // 在中断服务程序中执行相应的处理逻辑
    // 例如更新计数器、切换状态等
    // 这里只是简单地将LED的状态取反
    PORTB ^= (1 << PB0); // 切换PB0引脚的状态（假设连接了一个LED）
}

int main() {
    // 初始化定时器1
    TCCR1B |= (1 << CS10) | (1 << CS12); // 设置预分频器为1024
    TCNT1 = 0; // 清零计数器
    TIMSK1 |= (1 << TOIE1); // 开启定时器1溢出中断

    // 配置LED引脚为输出
    DDRB |= (1 << PB0); // 设置PB0引脚为输出

    // 开启全局中断使能
    sei();

    while (1) {
        // 主程序中可以执行其他任务
    }

    return 0;
}

在这个示例中，我们使用了AVR单片机的Timer/Counter1模块来实现定时器功能，并注册了一个定时器溢出中断服务程序（ISR）。当定时器溢出时，硬件会自动触发这个中断，并执行ISR中的代码。在ISR中，我们可以执行一些需要立即处理的任务，例如更新计数器、切换系统状态等。在主程序中，我们可以执行其他任务，例如轮询IO、处理其他中断等。

通过合理地使用中断服务程序，我们可以实现对外部事件的及时响应和处理，提高系统的实时性和可靠性。

有限状态机（FSM）：

有限状态机（FSM）是一种描述系统状态和状态转换的数学模型，通常用于建模具有多种状态和状态转换的系统。在单片机开发中，有限状态机常常用于管理系统的状态和控制逻辑，例如控制系统、通信协议等。

以下是一个简单的示例，演示了如何在单片机开发中实现有限状态机（FSM）：

假设我们正在开发一个基于单片机的简单游戏，游戏中有两个状态：等待玩家输入和游戏进行中。在等待玩家输入状态下，系统等待玩家按下按钮开始游戏；在游戏进行中状态下，系统会不断更新游戏状态并响应玩家的操作。

#include <avr/io.h>
#include <avr/interrupt.h>

// 定义状态枚举
typedef enum {
    WAITING,
    PLAYING
} GameState;

// 定义游戏状态变量
volatile GameState state = WAITING;

// 按钮按下中断服务程序（ISR）
ISR(INT0_vect) {
    // 按钮按下时，切换到游戏进行中状态
    state = PLAYING;
}

int main() {
    // 配置按钮引脚为输入，使能上拉电阻
    DDRD &= ~(1 << PD2); // PD2为按钮引脚
    PORTD |= (1 << PD2); // 开启PD2引脚的上拉电阻

    // 配置外部中断0（INT0）
    EICRA |= (1 << ISC01); // 设置下降沿触发
    EIMSK |= (1 << INT0); // 开启INT0中断

    // 开启全局中断使能
    sei();

    while (1) {
        // 根据当前状态执行相应的操作
        switch (state) {
            case WAITING:
                // 在等待玩家输入状态下执行一些操作
                break;
            case PLAYING:
                // 在游戏进行中状态下执行一些操作
                break;
        }
    }

    return 0;
}

在这个示例中，我们使用了AVR单片机的外部中断0（INT0）来模拟按钮的按下事件，当按钮按下时，硬件会自动触发INT0中断，并执行INT0中断服务程序（ISR）。在ISR中，我们切换了状态变量 state 的值，将状态从等待玩家输入切换到游戏进行中。在主程序中，我们根据当前状态执行相应的操作，例如在等待玩家输入状态下等待按钮按下，而在游戏进行中状态下执行游戏逻辑。

通过有限状态机的设计，我们可以清晰地定义系统的状态和状态转换规则，简化了单片机程序的设计和实现。

命令模式：

命令模式是一种行为设计模式，它允许将请求或操作封装成单独的对象，从而使得可以参数化客户端对象并以队列方式执行请求、将请求记录日志、支持撤销操作等。

在单片机开发中，命令模式通常用于将命令封装成对象，以便在系统中灵活地控制和管理命令的执行。

以下是一个简单的示例，演示了如何在单片机开发中应用命令模式：

假设我们正在开发一个智能家居控制系统，有几个可以控制的设备，例如灯、风扇和空调。我们可以将控制命令封装成对象，并在系统中以队列方式执行这些命令。

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

// 定义设备类型
typedef enum {
    LIGHT,
    FAN,
    AIR_CONDITIONER
} DeviceType;

// 定义命令结构体
typedef struct {
    DeviceType device;
    void (*action)();
} Command;

// 命令执行函数：打开灯
void turnOnLight() {
    printf("灯已打开\n");
}

// 命令执行函数：关闭灯
void turnOffLight() {
    printf("灯已关闭\n");
}

// 命令执行函数：打开风扇
void turnOnFan() {
    printf("风扇已打开\n");
}

// 命令执行函数：关闭风扇
void turnOffFan() {
    printf("风扇已关闭\n");
}

// 命令执行函数：打开空调
void turnOnAirConditioner() {
    printf("空调已打开\n");
}

// 命令执行函数：关闭空调
void turnOffAirConditioner() {
    printf("空调已关闭\n");
}

int main() {
    // 创建命令数组
    Command commands[] = {
        {LIGHT, turnOnLight},
        {FAN, turnOnFan},
        {AIR_CONDITIONER, turnOnAirConditioner}
    };

    // 执行命令
    for (int i = 0; i < sizeof(commands) / sizeof(commands[0]); i++) {
        commands[i].action();
    }

    return 0;
}

在这个示例中，我们定义了三种设备类型：灯、风扇和空调，并实现了对应的打开和关闭命令执行函数。然后，我们创建了一个命令数组，每个命令包含了设备类型和对应的命令执行函数。最后，我们遍历命令数组，依次执行每个命令的执行函数。

这个示例展示了如何使用纯C语言实现一个简单的命令模式，将命令封装成对象，并以数组的形式管理和执行命令。

观察者模式：

定义一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。在单片机开发中，可以用于实现事件触发机制、消息订阅等功能。

观察者模式是一种行为设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听并收到目标对象状态的变化通知。在单片机开发中，观察者模式通常用于实现事件驱动的系统，其中多个模块或组件可以注册为观察者，以便在事件发生时接收通知并执行相应的操作。

以下是一个简单的示例，演示了如何在单片机开发中应用观察者模式：

假设我们正在开发一个基于单片机的环境监测系统，系统可以监测温度和湿度，并在这些数据发生变化时通知所有观察者。

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

// 定义观察者接口
typedef struct {
    void (*update)(int); // 更新方法，用于接收数据变化通知
} Observer;

// 定义目标对象类
typedef struct {
    int temperature; // 温度数据
    int humidity;    // 湿度数据
    Observer **observers; // 观察者数组
    int capacity;    // 观察者数组容量
    int count;       // 观察者数量
} Subject;

// 初始化目标对象
Subject *createSubject(int capacity) {
    Subject *subject = (Subject *)malloc(sizeof(Subject));
    subject->temperature = 0;
    subject->humidity = 0;
    subject->observers = (Observer **)malloc(capacity * sizeof(Observer *));
    subject->capacity = capacity;
    subject->count = 0;
    return subject;
}

// 添加观察者
void attachObserver(Subject *subject, Observer *observer) {
    if (subject->count < subject->capacity) {
        subject->observers[subject->count++] = observer;
    }
}

// 更新数据并通知观察者
void setDataAndNotifyObservers(Subject *subject, int temperature, int humidity) {
    subject->temperature = temperature;
    subject->humidity = humidity;
    // 通知所有观察者
    for (int i = 0; i < subject->count; i++) {
        subject->observers[i]->update(temperature);
    }
}

// 定义具体观察者：温度显示模块
void temperatureDisplayUpdate(int temperature) {
    printf("当前温度：%d\n", temperature);
}

// 定义具体观察者：湿度显示模块
void humidityDisplayUpdate(int temperature) {
    printf("当前湿度：%d\n", temperature);
}

int main() {
    // 创建目标对象
    Subject *environmentMonitor = createSubject(2);

    // 创建观察者对象并注册到目标对象中
    Observer temperatureDisplay = {temperatureDisplayUpdate};
    Observer humidityDisplay = {humidityDisplayUpdate};
    attachObserver(environmentMonitor, &temperatureDisplay);
    attachObserver(environmentMonitor, &humidityDisplay);

    // 模拟环境数据变化并通知观察者
    setDataAndNotifyObservers(environmentMonitor, 25, 50);

    // 模拟环境数据变化并通知观察者
    setDataAndNotifyObservers(environmentMonitor, 30, 60);

    // 释放资源
    free(environmentMonitor->observers);
    free(environmentMonitor);
    
    return 0;
}

在这个示例中，我们定义了一个 Observer 结构体表示观察者接口，其中包含一个 update 函数指针，用于接收数据变化通知。然后，我们定义了一个 Subject 结构体表示目标对象，其中包含了温度和湿度数据以及一个观察者数组。接着，我们实现了创建目标对象、添加观察者、更新数据并通知观察者等功能。最后，我们创建了两个具体观察者对象，并注册到目标对象中，然后模拟环境数据变化并通知观察者

策略模式：

策略模式是一种行为设计模式，它定义了一系列算法并将每个算法封装成单独的对象，使得它们可以相互替换。策略模式可以让算法的变化独立于使用算法的客户端，从而使得系统更加灵活、可扩展和易于维护。

在单片机开发中，策略模式通常用于封装不同的算法，并在运行时根据需要选择合适的算法来执行某个特定的任务。

以下是一个简单的示例，演示了如何在单片机开发中应用策略模式：

假设我们正在开发一个基于单片机的智能小车控制系统，小车需要根据不同的路况选择合适的行驶策略，例如直行、左转或右转。

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

// 定义策略接口
typedef struct {
    void (*execute)();
} Strategy;

// 定义具体策略：直行策略
void goStraight() {
    printf("小车直行\n");
}

// 定义具体策略：左转策略
void turnLeft() {
    printf("小车左转\n");
}

// 定义具体策略：右转策略
void turnRight() {
    printf("小车右转\n");
}

// 定义环境类
typedef struct {
    Strategy *strategy;
} Context;

// 设置策略
void setStrategy(Context *context, Strategy *strategy) {
    context->strategy = strategy;
}

// 执行策略
void executeStrategy(Context *context) {
    context->strategy->execute();
}

int main() {
    // 创建环境对象
    Context car;

    // 创建具体策略对象
    Strategy goStraightStrategy = {goStraight};
    Strategy turnLeftStrategy = {turnLeft};
    Strategy turnRightStrategy = {turnRight};

    // 小车根据不同路况选择策略并执行
    setStrategy(&car, &goStraightStrategy);
    executeStrategy(&car);

    setStrategy(&car, &turnLeftStrategy);
    executeStrategy(&car);

    setStrategy(&car, &turnRightStrategy);
    executeStrategy(&car);

    return 0;
}

在这个示例中，我们定义了一个 Strategy 结构体表示策略接口，其中包含一个 execute 函数指针，用于执行特定的策略。然后，我们实现了具体的直行、左转和右转策略。接着，我们定义了一个 Context 结构体表示环境类，其中包含了一个策略对象。最后，我们创建了一个小车对象，并根据不同的路况选择不同的策略执行行驶动作。

单例模式：

单例模式是一种创建型设计模式，用于确保类只有一个实例，并提供全局访问点。在单片机开发中，单例模式通常用于管理全局资源或共享资源，例如配置管理器、日志记录器等。

以下是一个简单的示例，演示了如何在单片机开发中实现单例模式

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

// 定义单例类
typedef struct {
    // 这里定义单例类的成员变量
    int data;
} Singleton;

// 静态变量用于保存单例实例
static Singleton *instance = NULL;

// 获取单例实例的方法
Singleton *getInstance() {
    // 如果实例不存在，则创建一个新实例
    if (instance == NULL) {
        instance = (Singleton *)malloc(sizeof(Singleton));
        // 这里可以进行一些初始化操作
        instance->data = 0;
    }
    return instance;
}

// 销毁单例实例的方法（可选）
void destroyInstance() {
    if (instance != NULL) {
        free(instance);
        instance = NULL;
    }
}

int main() {
    // 获取单例实例
    Singleton *singleton1 = getInstance();
    Singleton *singleton2 = getInstance();

    // 判断是否是同一个实例
    if (singleton1 == singleton2) {
        printf("singleton1 和 singleton2 是同一个实例\n");
    } else {
        printf("singleton1 和 singleton2 不是同一个实例\n");
    }

    // 可以通过单例实例访问成员变量
    singleton1->data = 123;
    printf("singleton1->data = %d\n", singleton1->data); // 输出：123
    printf("singleton2->data = %d\n", singleton2->data); // 输出：123

    // 销毁单例实例（可选）
    destroyInstance();

    return 0;
}

在这个示例中，我们定义了一个 Singleton 结构体表示单例类，其中包含了一个 data 成员变量作为示例。然后，我们通过一个静态变量 instance 来保存单例实例，并提供了一个 getInstance() 方法用于获取单例实例。在 getInstance() 方法中，如果实例不存在，则创建一个新实例；否则返回已有的实例。最后，我们在 main() 函数中测试了单例实例是否是同一个，以及通过单例实例访问成员变量的功能。

参考文章

设计模式：其他博主文章

woainizhongguo.
关注
  • 23
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言-设计模式汇总，包含23中常见设计模式，利用C语言实现；
10-10
C语言-设计模式汇总，包含23中常见设计模式，利用C语言实现；
C语言设计模式
05-21
23个经典设计模式的C实现，非常值得收藏，研究，学习本质
C语言模块化编程
最新发布
m0_64148419的博客
06-24 388
C语言中如何拆分.c文件，使用模块化编程。
C语言设计模式：实现简单工厂模式和工程创建_数据工厂c语言(1)
2301_79099434的博客
04-16 315
● 工厂模式是最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的（最佳）方式；● 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象；● 共同的接口：我们自己创建共同接口API，从工厂里面获得需要的对象放入main函数中去运行。
用 C 语言编写设计模式--模板模式
weixin_46564301的博客
06-11 285
在抽象类中统一操作步骤，并规定好接口；让子类实现接口。这样可以把各个具体的子类和操作步骤解耦合虽然C语言是面向过程的编程语言，但是我们在设计程序的时候，可以考虑用面向对象的方式去设计，这样提高我们程序的“高内聚、低耦合”特性，便于维护。需要C语言实现设计模式代码的小伙伴：在微信公众号【Linux编程用C】后台回复 【designer】 即可获取，不断更新中！欢迎大家加小C微信【LinuxCodeUseC】，我们一起交流讨论学习！PS：若大家想看C语言版本的其他设计模式，转发！关注吧！~~
C语言开发中的“设计模式”
yimuta9538的博客
06-08 1700
在 C 语言开发中，虽然没有像面向对象编程语言那样的设计模式，但是可以借鉴一些通用的设计原则和思想。
【知识分享】C语言中的设计模式——开篇
知识噬元兽的博客
07-31 4091
从一个普通的码农成为架构师的第一步，就是要从代码搬运转化为有自己一套设计方法。架构设计的基石，就是要拥有一套可信手拈来的设计模式。
C语言实现设计模式之行为模式：策略模式
和风化雨
08-14 549
行为模式主要用于解决if--else过多的问题 命令模式一般用于输出仅与本次输入输入有关，与以前的输入无关。 一种输入根据处理方法的可以有多种输出。 处理的方法可以自由调整。 举例：针对不同人的打折销售 #ifndef REQUEST_H #define REQUEST_H typedef struct{ ... }Request; typedef enum{HANDLE1=0,...,HANDLEN}HandlerType; void handleRequest(Request *r, Han
嵌入式 C 语言设计模式，在STC89C52上的应用
zp1990412的专栏
05-26 504
状态机模式：状态机模式是一种常用的嵌入式系统设计模式，可以用于处理多状态的控制逻辑。状态机模式将系统的状态和状态转换定义为一组状态和转换规则，通过状态转换来实现控制逻辑。观察者模式：观察者模式是一种常用的事件处理模式，可以用于处理系统中的事件通知。观察者模式将事件处理和事件通知分离开来，通过注册和通知机制来实现事件处理。适配器模式：适配器模式是一种常用的接口转换模式，可以用于处理系统中的接口兼容问题。适配器模式将不兼容的接口转换为兼容的接口，从而实现系统的兼容性。
C语言和设计模式（总结篇）
gooogleman#foxmail.com
10-16 826
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 设计模式的书相信很多人都看过。对于设计模式这样一种方法，相信不同的人有不同的理解。我在这里写的博客只是我个人对设计模式的粗浅认识。文中肯定存在很多的不足和不成熟之处，希望朋友们谅解。望大家多多指正，谢谢！ 01）C语言和设计模式（继承、封装、多态） 02）C语言和设计模式（访问者...
23种设计模式解析与c++实现源代码.
08-09
23中设计模式大家都应该知道吧，我从别处收集过来的，书里面讲解清晰明了，里面的例子可以直接编译通过，我将例子整理了一下（全部在VC6.0中编译通过）单独放在了一个目录了，方便大家学习使用，希望大家看了之后有所收获
C语言的设计模式
01-27
但往往就是这些不符合单一职责原则的设计可能导致一些很难发现的BUG。看看下面这段代码： 可能很多人一眼看上去并没有什么问题，先让我们看看这个库函数的定义：正常情况下pBuf是新空间的地址没有任何问题，但我们...
C语言设计模式--单例模式
qq_33471732的博客
04-01 472
在此示例中，我们使用静态变量 instance 来保存唯一实例的状态，并在 get_singleton_instance() 函数中进行实例化。当第一次调用 get_singleton_instance() 时，它将创建唯一实例，并返回指向该实例的指针。在随后的调用中，该函数将返回相同的实例。在 C 语言中实现单例模式需要使用静态变量来保持唯一实例的状态，并提供一个全局函数来获取该实例。【最后一个bug】多平台都有更新和发布，大家可以一键三连，关注+星标，不错过精彩内容~
C语言设计模式：实现简单工厂模式和工程创建
m0_74985965的博客
03-07 1367
● 设计模式是建筑设计领域引入到计算机科学中来的；● 设计模式是对面向对象设计中反复出现的问题的解决方案；● 算法不是设计模式，因为算法致力于解决问题而非设计问题；● 设计模式通常描述了一组相互紧密作用的类与对象；● 设计模式使代码更稳定，更安全，拓展性更强，同时也方便代码重构。● 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象；● 共同的接口：我们自己创建共同接口API，从工厂里面获得需要的对象放入main函数中去运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值