设计模式(持续更新)

单例模式：

懒汉：

public:
    static Instance& getInstance()
    {
        static instance=new Instance();
        return instance;
    }
前提:Instance(const Instance&)=delete;
Instance(Instance&&)=delete;
Instance& operator=(const Instance&) = delete;

线程安全的懒汉模式 

线程安全的：
class Instance{
private:
static Instance* instance;
mutex mut;
public:
static Instance* getInstance();
}
Instance *Instance::instance=nullptr;
Instance::mut;
Instance* Instance::getInstance()
{
    if(instance==nullptr)
    {
        lock_guard<mutex>lock(mut);
        if(instance==nullptr)
        {
            instance=new Instance();
        }
    
    }
    return instance;
}

饿汉模式： 

class Instance{
private:
static Instance instance=new Instance();
mutex mut;
public:
static Instance& getInstance();
}
Instance& Instance::getInstance()
{
    return instance;
}

工厂模式： 

比较简单但是代码很多，直接放图：

简单工厂：

就是创业公司，一个人干多个活

工厂方法：

外包，丢给你一个专门的业务

 抽象工厂：

大厂的核心部门，一个具体工厂干很多核心业务

代理模式： 

代理模式就是秘书或者CEO

如果将boss作为基类，那么ceo类就是要委托的类。那么部门不同的主管，财务，普通员工都有不同的功能，因为假设ceo具有最高权限，则是ceo赋权给其他人。

ceo：

class boss
{
public: 
virtual void pay() = 0;
virtual void work() = 0;
virtual void employ() = 0;
};

ceo：

class ceo: public boss //委托老板
{
public:
    void work()override
    {
        cout<<"打工人努力工作"<<endl;
    }
    void pay()override
    {
        cout<<"财务发放工资"<<endl;
    }
    void employ()override
    {
        cout<<"高级打工人雇佣其他人"<<endl;
    }
}; 

普通员工employ的代理：

class employProxy: public boss
{
public: 
    employProxy(){boss = new ceo();}
    ~employProxy(){delete boss;
    }
     void pay()override
    {
       cout<<"普通工人无法支付工资"<<endl;
    }
    virtual void work()override 
    {
        boss->work();
    }
    virtual void employ() override
    {
        cout<<"普通工人无法雇佣其他人"<<endl;
    }
private:
    boss *boss;
};

财务caiwuProxy：

class caiwuProxy: public boss
{
public: 
    caiwuProxy(){boss = new ceo();}
    ~caiwuProxy(){delete boss;
        
    }
     void pay()override
    {
       boss->pay();
    }
    virtual void work()override 
    {
        boss->work();
    }
    virtual void employ() override
    {
        cout<<"财务无法雇佣其他人"<<endl;
    }
private:
    boss *boss;
};

部门管理的proxy：

class managerProxy: public boss
{
public: 
    managerProxy(){boss = new ceo();}
    ~managerProxy(){delete boss;}
     void pay()override
    {
        boss->pay();
    }
    virtual void work()override 
    {
        boss->work();
    }
    virtual void employ() override
    {
        boss->employ();
    }
private:
    boss *boss;
};

 这里可能逻辑不是很合适，比如主管不能控制财务，这里假设这么做，只是为了体现权限的问题。

适配器模式：

以常见的耳机3.5mm音频接口和usb接口的转换作为媒介，适配器就是匹配这个接口的媒介

3.5mm音频接口：

// 目标接口
class USB {
public:
    virtual void Request() const {
        std::cout << "USB接口.\n";
    }
    virtual ~Target() = default;
};

usb：

// 需要适配的类
class AdapteeTS {
public:
    void SpecificRequest() const {
        std::cout << "AdapteeTS: 3.5mm音频接口播放.\n";
    }
};

真正的适配器类：

// 适配器类
class Adapter : public USB {
private:
    AdapteeTS adaptee_; // 组合

public:
    void Request() const override {
        // 将适配者的接口转换为目标接口
        std::cout << "将3.5mm音频接口通过适配器转化为USB接口\n";
        adaptee_.SpecificRequest();
    }
};

 调试代码：

// 客户端代码
void ClientCode(const Target& target) {
    target.Request();
}

int main() {
    std::cout << "Client: I can work just fine with the Target objects:\n";
    Target target;
    ClientCode(target);

    std::cout << "\nClient: The Adaptee class has a weird interface. See, I don't understand it:\n";
    Adaptee adaptee;
    adaptee.SpecificRequest();

    std::cout << "\nClient: But I can work with it via the Adapter:\n";
    Adapter adapter;
    ClientCode(adapter);

    return 0;
}