C++高階應用_設計模式

hwaityd發表於2024-10-20
C++設計模式

在C++中，設計模式是一套被廣泛認可的解決特定程式設計問題的最佳實踐。這些模式可以幫助開發者構建靈活、可維護和可重用的程式碼。以下是一些最常見的設計模式及其在C++中的應用：

1. 單例模式（Singleton）

概念：確保一個類只有一個例項，並提供一個全域性訪問點。
原理：使用私有建構函式和靜態例項變數。
用法：通常用於管理共享資源，如配置資訊、執行緒池等。

案例程式碼：

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

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

Singleton* Singleton::instance = nullptr;

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    assert(s1 == s2); // 確保是同一個例項
    return 0;
}

2. 工廠模式（Factory Method）

概念：定義一個建立物件的介面，但讓子類決定例項化哪個類。
原理：使用多型來建立物件。
用法：用於程式碼中需要生成一系列相關或依賴物件的場景。

案例程式碼：

class Product {
public:
    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        cout << "Using A" << endl;
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        cout << "Using B" << endl;
    }
};

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

int main() {
    Factory* factory = new ConcreteFactoryA();
    Product* product = factory->createProduct();
    product->use(); // 使用A
    delete product;
    delete factory;
    return 0;
}

3. 觀察者模式（Observer）

概念：定義物件間的一種一對多的依賴關係，當一個物件改變狀態時，所有依賴於它的物件都得到通知並自動更新。
原理：使用回撥函式或事件。
用法：用於實現資料和檢視之間的同步，如模型-檢視-控制器（MVC）架構。

案例程式碼：

#include <list>
#include <algorithm>

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

class Subject {
private:
    std::list<Observer*> observers;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    void detach(Observer* observer) {
        observers.remove(observer);
    }
    void notify() {
        for (auto observer : observers) {
            observer->update();
        }
    }
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        cout << "Observer updated" << endl;
    }
};

int main() {
    Subject subject;
    ConcreteObserver observer;
    subject.attach(&observer);
    subject.notify(); // 通知所有觀察者
    subject.detach(&observer);
    return 0;
}

4. 策略模式（Strategy）

概念：定義一系列演算法，將每個演算法封裝起來，並使它們可以互換使用。
原理：使用多型來動態選擇演算法。
用法：用於需要動態改變演算法或行為的場景。

案例程式碼：

class Context {
public:
    virtual void executeStrategy() = 0;
};

class ConcreteStrategyA : public Context {
public:
    void executeStrategy() override {
        cout << "Executing Strategy A" << endl;
    }
};

class ConcreteStrategyB : public Context {
public:
    void executeStrategy() override {
        cout << "Executing Strategy B" << endl;
    }
};

class Strategy {
public:
    virtual void algorithm() = 0;
};

class ContextClient {
private:
    Strategy* strategy;
public:
    void setStrategy(Strategy* strategy) {
        this->strategy = strategy;
    }
    void executeStrategy() {
        strategy->executeStrategy();
    }
};

int main() {
    ContextClient client;
    client.setStrategy(new ConcreteStrategyA());
    client.executeStrategy(); // 執行策略A
    client.setStrategy(new ConcreteStrategyB());
    client.executeStrategy(); // 執行策略B
    return 0;
}

這些設計模式提供了一套通用的解決方案，可以幫助開發者解決特定的程式設計問題，並提高程式碼的可維護性和可擴充套件性。在實際開發中，根據具體需求選擇合適的設計模式是非常重要的。

相關文章