Quels sont les modèles de conception C++ pour les systèmes embarqués ?

Les modèles de conception C++ intégrés peuvent être utilisés pour créer un code efficace et fiable, adapté aux environnements aux ressources limitées : Modèle Singleton : garantit qu'il n'y a qu'une seule instance d'une classe spécifique utilisée pour gérer les ressources. Modèle d'observateur : permet aux objets de s'abonner à d'autres objets et de recevoir des notifications de changements d'état. Modèle de méthode d'usine : crée un objet basé sur un type sans spécifier la classe exacte. Cas pratique : Le système de planification de tâches utilise ces modes pour réaliser une planification de tâches efficace et garantir l’exécution fiable des tâches clés.

Modèles de conception C++ pour les systèmes embarqués

Introduction

Les systèmes embarqués fonctionnent généralement dans des environnements aux ressources limitées et doivent être efficaces et fiables. Les modèles de conception C++ aident les ingénieurs à créer un code embarqué concis, maintenable et évolutif.

Modèles de conception C++ pour les systèmes embarqués

Modèle Singleton : Garantit qu'il n'y a qu'une seule instance d'une classe donnée dans l'application qui peut être utilisée pour gérer les ressources.

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

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

Modèle d'observateur : Permet aux objets de s'abonner à d'autres objets et de recevoir des notifications de leurs changements d'état.

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 : Créez une implémentation concrète d'un objet sans spécifier sa classe exacte.

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;
}

Cas pratique : système de planification de tâches

Lors de la mise en œuvre d'un planificateur de tâches dans des systèmes embarqués aux ressources limitées, vous pouvez tirer parti des modèles de conception. Ce système contient des tâches, des files d'attente de tâches et des planificateurs :

• Mode Singleton : Utilisé pour gérer les files d'attente de tâches et les planificateurs, garantissant une entité unique qui contrôle l'exécution des tâches.
• Modèle d'observateur : Les tâches s'abonnent à un planificateur singleton pour recevoir des notifications de modifications d'horaire.
• Modèle de méthode d'usine : Créez des objets de tâche spécifiques en fonction du type de tâche.

En adoptant ces modèles de conception, un système de planification de tâches efficace, robuste et évolutif peut être créé pour fournir une exécution fiable des tâches critiques dans les systèmes embarqués.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!