嵌入式系统软件设计模式：创建型模式

boringhex.top

于 2024-12-31 09:45:10 发布

阅读量1k

点赞数 30

分类专栏： MCU 文章标签：设计模式

本文链接：https://blog.youkuaiyun.com/PengWon/article/details/144841240

版权

MCU 专栏收录该内容

99 篇文章

订阅专栏

在嵌入式系统开发中，设计模式是提高代码质量和系统可靠性的重要工具。本文将探讨创建型模式在嵌入式系统中的应用，重点介绍它们如何帮助开发者在资源受限的环境中高效地创建对象。

1. 引言：创建型模式在嵌入式系统中的重要性

嵌入式系统通常面临资源有限、实时性要求高和系统复杂性增加的挑战。创建型模式提供了一种高效的对象创建机制，适用于这些特定环境。本文将逐一探讨几种常见的创建型模式，并提供它们在嵌入式系统中的应用示例。

2. 单例模式 (Singleton Pattern)

描述与标准用例

单例模式确保一个类只有一个实例，并提供一个全局访问点。适用于需要统一管理硬件资源的场景，如硬件驱动。

嵌入式系统中的应用

在嵌入式系统中，单例模式常用于管理唯一实例的硬件资源，如GPIO驱动。

示例代码 ©

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

typedef struct {
    int pin;
} GPIO;

GPIO* GPIO_Instance = NULL;

GPIO* GPIO_GetInstance() {
    if (GPIO_Instance == NULL) {
        GPIO_Instance = (GPIO*)malloc(sizeof(GPIO));
        if (GPIO_Instance == NULL) {
            return NULL;
        }
        GPIO_Instance->pin = 0;
    }
    return GPIO_Instance;
}

讨论

在无操作系统的嵌入式环境中，单例模式的线程安全问题通常不显著，但仍需注意内存管理。

3. 工厂方法模式 (Factory Method Pattern)

描述与标准用例

工厂方法模式定义一个创建对象的接口，但由子类决定实例化哪个类。适用于需要根据不同硬件平台创建相应对象的场景。

嵌入式系统中的应用

用于创建硬件抽象层（HAL）对象，适应不同微控制器平台。

示例代码 ©

#include <stdio.h>

typedef void (*UART_Init)(void);

struct UART {
    UART_Init init;
};

UART* UART_Create(UART_Init init) {
    UART* uart = (UART*)malloc(sizeof(UART));
    if (uart == NULL) {
        return NULL;
    }
    uart->init = init;
    return uart;
}

讨论

工厂方法模式提高了系统的灵活性和可扩展性，适用于多平台支持。

4. 抽象工厂模式 (Abstract Factory Pattern)

描述与标准用例

抽象工厂模式提供一个创建一系列相关或依赖对象的接口，而无需指定它们的具体类。适用于管理不同家族的硬件外设。

嵌入式系统中的应用

用于管理不同制造商的传感器家族。

示例代码 ©

#include <stdio.h>

typedef struct {
    void (*create_sensor)(void);
} SensorFactory;

SensorFactory* SensorFactory_Create() {
    SensorFactory* factory = (SensorFactory*)malloc(sizeof(SensorFactory));
    if (factory == NULL) {
        return NULL;
    }
    // 初始化创建传感器的方法
    return factory;
}

讨论

抽象工厂模式便于管理多个产品家族，适用于复杂系统。

5. 建造者模式 (Builder Pattern)

描述与标准用例

建造者模式通过逐步构建复杂对象。适用于构建复杂数据结构，如网络数据包。

嵌入式系统中的应用

用于构建复杂的数据包或配置结构。

示例代码 ©

#include <stdio.h>

typedef struct {
    int header;
    int payload;
} Packet;

typedef struct {
    Packet* packet;
    void (*set_header)(Packet*, int);
    void (*set_payload)(Packet*, int);
} PacketBuilder;

void set_header(Packet* packet, int header) {
    packet->header = header;
}

void set_payload(Packet* packet, int payload) {
    packet->payload = payload;
}

PacketBuilder* PacketBuilder_Create() {
    PacketBuilder* builder = (PacketBuilder*)malloc(sizeof(PacketBuilder));
    if (builder == NULL) {
        return NULL;
    }
    builder->packet = (Packet*)malloc(sizeof(Packet));
    builder->set_header = set_header;
    builder->set_payload = set_payload;
    return builder;
}

讨论

建造者模式通过逐步构建对象，提高了代码的可读性和维护性。

6. 原型模式 (Prototype Pattern)

描述与标准用例

原型模式通过克隆现有对象来创建新对象，避免重复创建开销。适用于创建相似对象的场景。

嵌入式系统中的应用

用于克隆相似对象，减少内存开销。

示例代码 ©

#include <stdio.h>
#include <string.h>

typedef struct {
    int data;
} Object;

Object* Object_Clone(Object* obj) {
    Object* clone = (Object*)malloc(sizeof(Object));
    if (clone == NULL) {
        return NULL;
    }
    memcpy(clone, obj, sizeof(Object));
    return clone;
}

讨论

原型模式适用于内存有限的环境，通过克隆减少对象创建的开销。

7. 对象池模式 (Object Pool Pattern)

描述与标准用例

对象池模式管理一组可复用的对象，避免频繁创建和销毁对象。适用于需要高效管理对象生命周期的场景。

嵌入式系统中的应用

用于管理一组可复用的对象，如网络数据包池。

示例代码 ©

#include <stdio.h>

typedef struct {
    int data;
} Object;

typedef struct {
    Object* objects;
    int size;
    int index;
} ObjectPool;

ObjectPool* ObjectPool_Create(int size) {
    ObjectPool* pool = (ObjectPool*)malloc(sizeof(ObjectPool));
    if (pool == NULL) {
        return NULL;
    }
    pool->objects = (Object*)malloc(size * sizeof(Object));
    if (pool->objects == NULL) {
        free(pool);
        return NULL;
    }
    pool->size = size;
    pool->index = 0;
    return pool;
}

Object* ObjectPool_GetObject(ObjectPool* pool) {
    if (pool->index < pool->size) {
        return &pool->objects[pool->index++];
    }
    return NULL;
}