Quels sont les modèles de conception couramment utilisés dans la conception de classes C++ ?

Les modèles de conception courants dans la conception de classes C++ incluent : Modèle Singleton : assurez-vous qu'une classe n'a qu'une seule instance. Modèle de méthode d'usine : crée des objets sans spécifier de classe concrète, permettant aux sous-classes de modifier le processus d'instanciation. Modèle d'observateur : définissez des dépendances un à plusieurs entre les objets. Lorsqu'un objet change, les autres objets dépendants reçoivent des notifications et sont mis à jour.

Modèles de conception couramment utilisés dans la conception de classes C++

Les modèles de conception sont des solutions universelles aux problèmes courants dans la conception de logiciels. Ils fournissent une approche structurée et réutilisable pour créer des logiciels, améliorant la maintenabilité, l'évolutivité et la flexibilité du code.

En C++, certains modèles de conception couramment utilisés incluent :

Modèle Singleton

• Intention : garantir qu'une classe n'a qu'une seule instance et fournir un point d'accès global.

• Exemple de code :

  class Singleton {
  private:
    static Singleton* instance;
    Singleton();
  public:
    static Singleton* getInstance();
    void doSomething();
  };
  
  Singleton* Singleton::instance = nullptr;
  
  Singleton* Singleton::getInstance() {
    if (instance == nullptr) {
        instance = new Singleton();
    }
    return instance;
  }

Factory Method Pattern

• Intention : créer un objet sans spécifier sa classe concrète, permettant aux sous-classes de modifier le processus d'instanciation.

• Exemple de code :

  class Product {
  public:
    virtual void operation() = 0;
  };
  
  class ConcreteProductA : public Product {
  public:
    void operation() override {
        // ...
    }
  };
  
  class ConcreteProductB : public Product {
  public:
    void operation() override {
        // ...
    }
  };
  
  class Factory {
  public:
    virtual Product* createProduct() = 0;
  };
  
  class ConcreteFactoryA : public Factory {
  public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
  };
  
  class ConcreteFactoryB : public Factory {
  public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
  };

Modèle d'observateur

• Intention : Définir une dépendance un-à-plusieurs entre les objets afin que lorsqu'un objet change, tous les objets qui en dépendent soient notifiés et automatiquement mis à jour.

• Exemple de code :

  class Observable {
  public:
    virtual void addObserver(Observer* observer) = 0;
    virtual void removeObserver(Observer* observer) = 0;
    virtual void notifyObservers() = 0;
  };
  
  class Observer {
  public:
    virtual void update(Observable* observable) = 0;
  };
  
  class ConcreteObservable : public Observable {
  private:
    std::vector<Observer*> observers;
  public:
    void addObserver(Observer* observer) override {
        observers.push_back(observer);
    }
    void removeObserver(Observer* observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }
    void notifyObservers() override {
        for (auto observer : observers) {
            observer->update(this);
        }
    }
    void doSomething() {
        // ...
        notifyObservers();
    }
  };
  
  class ConcreteObserverA : public Observer {
  public:
    void update(Observable* observable) override {
        // ...
    }
  };
  
  class ConcreteObserverB : public Observer {
  public:
    void update(Observable* observable) override {
        // ...
    }
  };

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!