Was sind die am häufigsten verwendeten Entwurfsmuster beim C++-Klassenentwurf?

Zu den gängigen Entwurfsmustern im C++-Klassenentwurf gehören: Singleton-Muster: Stellen Sie sicher, dass eine Klasse nur eine Instanz hat. Factory-Methodenmuster: Erstellt Objekte ohne Angabe einer konkreten Klasse, sodass Unterklassen den Instanziierungsprozess ändern können. Beobachtermuster: Definieren Sie Eins-zu-Viele-Abhängigkeiten zwischen Objekten. Wenn sich ein Objekt ändert, erhalten andere abhängige Objekte Benachrichtigungen und Aktualisierungen.

Häufig verwendete Designmuster im C++-Klassendesign

Designmuster sind universelle Lösungen für häufige Probleme im Softwaredesign. Sie bieten einen strukturierten und wiederverwendbaren Ansatz zum Erstellen von Software und verbessern die Wartbarkeit, Skalierbarkeit und Flexibilität des Codes.

In C++ gehören zu den häufig verwendeten Entwurfsmustern:

Singleton-Muster

• Absicht: Stellen Sie sicher, dass eine Klasse nur eine Instanz hat und stellen Sie einen globalen Zugriffspunkt bereit.

• Beispielcode:

  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-Methodenmuster

• Absicht: Erstellen Sie ein Objekt, ohne seine konkrete Klasse anzugeben, sodass Unterklassen den Instanziierungsprozess ändern können.

• Beispielcode:

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

Beobachtermuster

• Absicht: Definieren Sie eine Eins-zu-viele-Abhängigkeit zwischen Objekten, sodass alle davon abhängigen Objekte benachrichtigt und automatisch aktualisiert werden, wenn sich ein Objekt ändert.

• Beispielcode:

  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 {
        // ...
    }
  };

Das obige ist der detaillierte Inhalt vonWas sind die am häufigsten verwendeten Entwurfsmuster beim C++-Klassenentwurf?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!