C++ 클래스 디자인에서 일반적으로 사용되는 디자인 패턴은 무엇입니까?

C++ 클래스 디자인의 일반적인 디자인 패턴은 다음과 같습니다. 싱글톤 패턴: 클래스에 인스턴스가 하나만 있는지 확인합니다. 팩토리 메소드 패턴: 구체적인 클래스를 지정하지 않고 객체를 생성하여 하위 클래스가 인스턴스화 프로세스를 변경할 수 있도록 합니다. 관찰자 패턴: 객체 간의 일대다 종속성을 정의합니다. 하나의 객체가 변경되면 다른 종속 객체가 알림을 받고 업데이트됩니다.

C++ 클래스 디자인에서 일반적으로 사용되는 디자인 패턴

디자인 패턴은 소프트웨어 디자인의 일반적인 문제에 대한 보편적인 솔루션입니다. 이는 소프트웨어 구축에 대한 체계적이고 재사용 가능한 접근 방식을 제공하여 코드 유지 관리성, 확장성 및 유연성을 향상시킵니다.

C++에서 일반적으로 사용되는 디자인 패턴은 다음과 같습니다.

싱글턴 패턴

• 의도: 클래스에 인스턴스가 하나만 있는지 확인하고 전역 액세스 포인트를 제공합니다.

• 샘플 코드:

  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 메서드 패턴

• 의도: 구체적인 클래스를 지정하지 않고 객체를 생성하여 하위 클래스가 인스턴스화 프로세스를 변경할 수 있도록 합니다.

• 샘플 코드:

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

Observer 패턴

• 의도: 객체가 변경되면 해당 객체에 종속된 모든 객체가 알림을 받고 자동으로 업데이트되도록 객체 간의 일대다 종속성을 정의합니다.

• 샘플 코드:

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

위 내용은 C++ 클래스 디자인에서 일반적으로 사용되는 디자인 패턴은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!