【学习笔记】设计模式Day2

策略模式

定义：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。该模式使得算法可独立于使用它的客户程序而变化

稳定点：客户程序与算法的调用关系
变化点：新家算法，算法内容改变

代码结构

#include<iostream>
using namespace std;
class Context {

};

// 稳定点：抽象去解决它
// 变化点：扩展（继承和组合）去解决它
class ProStategy {
public:
    virtual double CalcPro(const Context &ctx) = 0;
    virtual ~ProStategy();
};
// cpp
class VAC_Spring : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){
    }
};

class VAC_Spring_v2 : public VAC_Spring {
public:
    virtual double CalcPro(const Context &ctx){
        //....
    }
};

class VAC_worker : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

// cpp
class VAC_QiXi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
class VAC_QiXi1  : public VAC_QiXi {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_Wuyi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_GuoQing : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
class VAC_GuoQing2 : public VAC_GuoQing {
public:
    virtual double CalcPro(const Context &ctx){}
};

class VAC_Shengdan : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

// 设计原则：接口隔离原则
// 组合、继承
// 组合基类指针
// 两种方法：1. 采用具体接口选择算法  2. 依赖注入
class Promotion {
public:
    Promotion(ProStategy *sss = nullptr) : s(sss){}
    ~Promotion(){}
    void Choose(ProStategy *sss) {
        // 条件选择
        if (sss != nullptr) {
            s = sss;
        }
    }
    double CalcPromotion(const Context &ctx){
        if (s != nullptr) {
            return s->CalcPro(ctx);
        }
        return 0.0L;
    }
private:
    ProStategy *s;
};

int main () {
    Context ctx;
    ProStategy *s = new VAC_QiXi1();
    Promotion *p = new Promotion(s);
    p->Choose(new VAC_GuoQing2());
    p->CalcPromotion(ctx);
    return 0;
}

设计原则：接口隔离（依赖注入、通过一个接口解决两个类的依赖）、面向接口编程、开闭

单例模式

定义：保证一个类仅有一个实例，并提供一个该实例的全局访问点

稳定点：类只有一个实例，并且提供全局的访问点。
变化点：有多个单例，是否能复用代码

不希望用户去进行new＆delete，单例模式的实例伴随整个程序的生命周期，因此要隐藏构造函数（）和析构函数。

代码结构：
版本1：

class Singleton {
public:
    static Singleton * GetInstance() {
        if (_instance == nullptr) {
            _instance = new Singleton();
        }
        return _instance;
    }
private:
    Singleton(){}; //构造
    ~Singleton(){};
    Singleton(const Singleton &) = delete; //拷⻉构造
            Singleton& operator=(const Singleton&) =
    delete;//拷贝赋值构造
    Singleton(Singleton &&) = delete;//移动构造
    Singleton& operator=(Singleton &&) =
    delete;//移动拷贝构造
    static Singleton * _instance;//静态私有成员变量
};

Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

其中，函数后加=delete是显式删除
禁止返回值优化后，编译器行为：
1.找移动构造
2.找拷贝构造
3.报错

上述代码bug：静态成员是一个指针所以需要初始化，也不在静态空间所以无法调用析构函数，导致无法释放。

thanks to https://github.com/0voice