c++常用设计框架源码实现

以下是 C++ 常用设计框架的源码实现示例：

1. 单例模式

class Singleton {
public:
    static Singleton& GetInstance() {
        static Singleton instance;
        return instance;
    }
private:
    Singleton() {} // 防止外部实例化
    Singleton(const Singleton&); // 防止拷贝构造函数
    Singleton& operator=(const Singleton&); // 防止赋值操作
};

2. 工厂模式

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

class ProductA : public Product {
public:
    void Use() {
        std::cout << "ProductA is used" << std::endl;
    }
};

class ProductB : public Product {
public:
    void Use() {
        std::cout << "ProductB is used" << std::endl;
    }
};

class Factory {
public:
    virtual Product* CreateProduct() = 0;
};

class FactoryA : public Factory {
public:
    Product* CreateProduct() {
        return new ProductA();
    }
};

class FactoryB : public Factory {
public:
    Product* CreateProduct() {
        return new ProductB();
    }
};

3. 观察者模式

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

class Subject {
public:
    virtual void AddObserver(Observer* observer) = 0;
    virtual void RemoveObserver(Observer* observer) = 0;
    virtual void NotifyObservers() = 0;
};

class ConcreteObserver : public Observer {
public:
    void Update() {
        std::cout << "ConcreteObserver is updated" << std::endl;
    }
};

class ConcreteSubject : public Subject {
public:
    void AddObserver(Observer* observer) {
        observers_.push_back(observer);
    }

    void RemoveObserver(Observer* observer) {
        observers_.remove(observer);
    }

    void NotifyObservers() {
        for (auto observer : observers_) {
            observer->Update();
        }
    }

private:
    std::list<Observer*> observers_;
};

4. 装饰器模式

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

class ConcreteComponent : public Component {
public:
    void Operation() {
        std::cout << "ConcreteComponent operation" << std::endl;
    }
};

class Decorator : public Component {
public:
    Decorator(Component* component) : component_(component) {}

    void Operation() {
        component_->Operation();
    }

private:
    Component* component_;
};

class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component* component) : Decorator(component) {}

    void Operation() {
        Decorator::Operation();
        std::cout << "ConcreteDecoratorA operation" << std::endl;
    }
};

class ConcreteDecoratorB : public Decorator {
public:
    ConcreteDecoratorB(Component* component) : Decorator(component) {}

    void Operation() {
        Decorator::Operation();
        std::cout << "ConcreteDecoratorB operation" << std::endl;
    }
};

以上是常用的设计模式实现示例，其中代码仅供参考，实际使用中需要根据需求进行修改和拓展。