What are the C++ design patterns for embedded systems?

Embedded C design patterns can be used to create efficient and reliable code, suitable for resource-constrained environments: Singleton pattern: ensures that there is only one instance of a specific class used to manage resources. Observer Pattern: Allows objects to subscribe to other objects and receive notifications of state changes. Factory Method Pattern: Creates an object based on a type without specifying the exact class. Practical case: The task scheduling system uses these modes to achieve efficient task scheduling and ensure the reliable execution of key tasks.

C Design Patterns for Embedded Systems

Introduction

Embedding Traditional systems often operate in resource-constrained environments and need to be efficient and reliable. C design patterns help engineers create concise, maintainable, and scalable embedded code.

C Design Patterns for Embedded Systems

Singleton Pattern: Ensures that only one instance of a given class is available in the application for managing resources.

class Singleton {
private:
    Singleton() {}  // 私有构造函数，防止直接创建
    static Singleton* instance_;

public:
    static Singleton* getInstance() {
        if (!instance_) {
            instance_ = new Singleton;
        }
        return instance_;
    }
};

Observer pattern: Allows objects to subscribe to other objects and receive notifications of changes in their state.

class Observable {
private:
    std::vector<Observer*> observers_;

public:
    void attach(Observer* observer) { observers_.push_back(observer); }
    void detach(Observer* observer) { observers_.erase(std::remove(observers_.begin(), observers_.end(), observer)); }
    void notify() {
        for (auto& observer : observers_) {
            observer->update();
        }
    }
};

class Observer {
public:
    virtual void update() = 0;
};

class ConcreteObserver1 : public Observer {
public:
    void update() { std::cout << "ConcreteObserver1: Received update." << std::endl; }
};

Factory Method Pattern: Creates a concrete implementation of an object without specifying its exact class.

class Shape {
public:
    virtual double getArea() = 0;
    virtual double getPerimeter() = 0;
};

class Circle : public Shape {
public:
    double getArea() override { return 3.14 * radius_; }
    double getPerimeter() override { return 2 * 3.14 * radius_; }

private:
    double radius_;
};

class Square : public Shape {
public:
    double getArea() override { return side_ * side_; }
    double getPerimeter() override { return 4 * side_; }

private:
    double side_;
};

class ShapeFactory {
public:
    static Shape* createShape(std::string type, double dimension) {
        if (type == "Circle") {
            return new Circle(dimension);
        } else if (type == "Square") {
            return new Square(dimension);
        } else {
            return nullptr;
        }
    }
};

int main() {
    Shape* circle = ShapeFactory::createShape("Circle", 5);
    std::cout << "Circle area: " << circle->getArea() << std::endl;
    Shape* square = ShapeFactory::createShape("Square", 3);
    std::cout << "Square area: " << square->getArea() << std::endl;
    return 0;
}

Practical case: Task scheduling system

When implementing a task scheduler in a resource-constrained embedded system, design patterns can be used. This system contains tasks, task queues and schedulers:

• Single case mode: is used to manage task queues and schedulers to ensure a single entity that controls task execution.
• Observer pattern: Tasks subscribe to the singleton scheduler to receive notifications of scheduling changes.
• Factory method pattern: Create a specific task object based on the task type.

By adopting these design patterns, you can create an efficient, robust, and scalable task scheduling system that provides reliable execution of critical tasks in embedded systems.

The above is the detailed content of What are the C++ design patterns for embedded systems?. For more information, please follow other related articles on the PHP Chinese website!