設計模式分類

一、創建型模式

創建型模式是指將對象的創建與使用分離，讓系統更加靈活地創建對象。常見的創建型模式包括：

1. 工廠模式

工廠模式是一種高級抽象的創建型模式，它利用工廠類（Factory）負責創建其他對象。工廠模式可以分為簡單工廠模式、工廠方法模式和抽象工廠模式。以下是一個簡單工廠模式的代碼示例：

class Animal{
public:
    virtual void speak() = 0;
};

class Dog : public Animal{
public:
    void speak() override{
        std::cout << "汪汪汪" << std::endl;
    }
};

class Cat : public Animal{
public:
    void speak() override{
        std::cout << "喵喵喵" <speak();
    }
    if(a2 != nullptr){
        a2->speak();
    }
    delete a1;
    delete a2;
    return 0;
}

2. 單例模式

單例模式是一種只允許一個對象實例的創建型模式，它常用於系統中全局狀態的管理。以下是一個單例模式的代碼示例：

class Singleton{
private:
    Singleton(){}
    static Singleton* instance;
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();
    std::cout << (s1 == s2) << std::endl; //輸出1
    return 0;
}

二、結構型模式

結構型模式是指如何將類和對象按照某種布局組成更大的結構。常見的結構型模式包括：

1. 適配器模式

適配器模式是一種將兩個不兼容的介面互相轉換的結構型模式，它常用於將老系統中的介面轉換為新系統中的介面。以下是一個類適配器模式的代碼示例：

class Target{
public:
    virtual void request() = 0;
};

class Adaptee{
public:
    void specificRequest(){
        std::cout << "適配器模式示例" <specificRequest();
    }
};

int main(){
    Adaptee* a = new Adaptee();
    Target* t = new Adapter(a);
    t->request();
    delete a;
    delete t;
    return 0;
}

2. 裝飾器模式

裝飾器模式是一種動態地給對象添加功能的結構型模式，它常用於不想增加子類的情況下，對對象的功能進行擴展。以下是一個裝飾器模式的代碼示例：

class Component{
public:
    virtual void operation() = 0;
};

class ConcreteComponent : public Component{
public:
    void operation() override{
        std::cout << "裝飾器模式示例" <operation();
        }
    }
};

class ConcreteDecorator : public Decorator{
public:
    ConcreteDecorator(Component* c) : Decorator(c){}
    void operation() override{
        Decorator::operation();
        std::cout << "被裝飾" <operation();

    Component* c2 = new ConcreteDecorator(c1);
    c2->operation();

    delete c1;
    delete c2;
    return 0;
}

三、行為型模式

行為型模式是指對象之間的通信方式及其分配職責的方式，常見的行為型模式包括：

1. 觀察者模式

觀察者模式是一種對象間的一對多依賴關係，當一個對象的狀態發生改變時，它的所有依賴者都會收到通知。以下是一個觀察者模式的代碼示例：

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

class Subject{
private:
    std::vector observers;
public:
    void attach(Observer* o){
        observers.push_back(o);
    }
    void detach(Observer* o){
        auto iter = std::find(observers.begin(), observers.end(), o);
        if(iter != observers.end()){
            observers.erase(iter);
        }
    }
    void notify(){
        for(auto obs: observers){
            obs->update(this);
        }
    }
    virtual int getState() = 0;
    virtual void setState(int state) = 0;
};

class ConcreteSubject : public Subject{
private:
    int state;
public:
    int getState() override{
        return state;
    }
    void setState(int s) override{
        state = s;
        notify();
    }
};

class ConcreteObserver : public Observer{
public:
    void update(Subject* s) override{
        std::cout << "觀察者收到通知，當前狀態為" <getState() <attach(o1);
    s->attach(o2);
    s->setState(1);
    s->detach(o1);
    s->setState(2);
    delete s;
    delete o1;
    delete o2;
    return 0;
}

2. 策略模式

策略模式是一種將不同演算法封裝起來，使它們可以相互替換的行為型模式，它常用於將演算法的變化獨立於使用演算法的客戶端。以下是一個策略模式的代碼示例：

class Strategy{
public:
    virtual int doOperation(int a, int b) = 0;
};

class AddStrategy : public Strategy{
public:
    int doOperation(int a, int b) override{
        return a + b;
    }
};

class SubStrategy : public Strategy{
public:
    int doOperation(int a, int b) override{
        return a - b;
    }
};

class Context{
private:
    Strategy* strategy;
public:
    void setStrategy(Strategy* s){
        strategy = s;
    }
    int executeStrategy(int a, int b){
        return strategy->doOperation(a, b);
    }
};

int main(){
    Context* c = new Context();
    c->setStrategy(new AddStrategy());
    std::cout <executeStrategy(1, 2) <setStrategy(new SubStrategy());
    std::cout <executeStrategy(3, 2) << std::endl;

    delete c;
    return 0;
}