C++设计模式

管理变化， 提高复用

两种手段：分解  抽象

八大原则：https://blog.youkuaiyun.com/mmk27_word/article/details/108521903

重构技法：

静态 -> 动态
早绑定 -> 晚绑定
继承 -> 组合
编译时依赖 -> 运行时依赖
紧耦合 -> 松耦合

关注抽象类&接口（基类比子类更加有用）
理清变化点和稳定点
审视依赖关系

高内聚，松耦合

重在通过八大原则去理解

解决的问题：

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设回计经验的总结。答使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
设计模式最主要解决的问题是通过封装和隔离变化点来处理软件的各种变化问题。
隔离变化的好处在于，将系统中经常变化的部分和稳定的部分隔离，有助于增加复用性，并降低系统耦合度。很多设计模式的意图中都明显地指出了其对问题的解决方案，学习设计模式的要点是发现其解决方案中封装的变化点。

GitHub上代码例子：https://github.com/liu-jianhao/Cpp-Design-Patterns

b站视频：https://www.bilibili.com/video/BV1cW41157n1?p

别人的整理：https://www.cnblogs.com/ssyfj/category/1283709.html

单例：

#include <iostream>
#include <cassert>
#include <atomic>
#include <vector>
#include <thread>
#include <sstream>
#include <mutex>
using namespace std;
mutex mu;
class Single {
private:
    static atomic<Single*>  m_Single;
    static int count;
    static mutex  singlemu;
    Single() { cout << " 构造 " << endl; }
    Single(const Single& single) {}
    Single& operator=(const Single& single){}
public:
    static  Single* getSingle() {
        // 多线程下在外加锁安全 在内不安全 ：分配内存 调用构造函数 返回指针 2 3顺序可能颠倒
       // mu.lock();
        Single* tmp = m_Single.load(memory_order_relaxed);
        atomic_thread_fence(memory_order_acquire);

        if (tmp == nullptr) {
            //mu.lock();

            lock_guard<mutex> lock(singlemu);
            tmp = m_Single.load(memory_order_relaxed);

            if (tmp == nullptr) {
                tmp = new Single;
                count++;    

                atomic_thread_fence(memory_order_release);
                m_Single.store(tmp, memory_order_relaxed);
            }
            //mu.unlock();
        }
        cout << count << endl;
        //mu.unlock();
        return m_Single;
    }


    void print() {
        cout << "print\n";
    }
};
atomic<Single*>  Single::m_Single;
mutex Single::singlemu;
static int count;
mutex  singlemu;
int Single::count = 0;
void func() {
    Single::getSingle();
}
int main() {
    thread t[110];
    for (int i = 1; i <= 10; i++) {
        t[i] = thread(func);
    }
    for (int i = 1; i <= 10; i++)
        t[i].join();
    return 0;
}

工厂模式：

#include <iostream>
#include <cassert>
#include <atomic>
#include <vector>
#include <thread>
#include <sstream>
#include <mutex>
using namespace std;
// 抽象类 和 抽象工厂
class Fruit {
public:
    virtual void sayname() = 0;
};
class FruitFactory {
public:
    virtual Fruit* getFruit() = 0;
};
class Apple : public Fruit {
public:
    virtual void sayname() {
        cout << "Apple" << endl;
    }
};
class Banana : public Fruit {
    virtual void sayname() {
        cout << "Banana" << endl;
    }
};
class AppleFactory : public FruitFactory {
public:
    virtual Fruit* getFruit() {
        return new Apple();
    }
};
class BananaFactory : public FruitFactory {
public:
    virtual Banana* getFruit() {
        return new Banana();
    }
};
int main() {
    Fruit* F = NULL;
    FruitFactory* FF = new AppleFactory();
    F = FF->getFruit();
    F->sayname();

    FF = new BananaFactory();
    F = FF->getFruit();
    F->sayname();
    return 0;
}

抽象工厂：

#include <iostream>
#include <cassert>
#include <atomic>
#include <vector>
#include <thread>
#include <sstream>
#include <mutex>
using namespace std;
// 抽象类 和 抽象工厂
class Fruit {
public:
    virtual void sayname() = 0;
    virtual ~Fruit() {}
};
// 获得一个产品族
class FruitFactory {
public:
    virtual Fruit* getApple() = 0;
    virtual Fruit* getBanana() = 0;
    virtual ~FruitFactory() {};
};
class NorthApple : public Fruit {
public:
    virtual void sayname() {
        cout << "NorthApple" << endl;
    }
};
class NorthBanana : public Fruit {
public:
    virtual void sayname() {
        cout << "NorthBanana" << endl;
    }
};

class NorthFruitFactory : public FruitFactory {
public:
    virtual Fruit* getApple() {
        return new NorthApple();
    }
    virtual Fruit* getBanana() {
        return new NorthBanana();
    }
};


class SouthApple : public Fruit {
public:
    virtual void sayname() {
        cout << "SouthApple" << endl;
    }
};
class SouthBanana : public Fruit {
public:
    virtual void sayname() {
        cout << "SouthBanana" << endl;
    }
};

class SouthFruitFactory : public FruitFactory {
public:
    virtual Fruit* getApple() {
        return new SouthApple();
    }
    virtual Fruit* getBanana() {
        return new SouthBanana();
    }
};
int main() {
    Fruit* F = NULL;
    FruitFactory* FF = new NorthFruitFactory();
    F = FF->getApple();
    F->sayname();
    F = FF->getBanana();
    F->sayname();

    FF = new SouthFruitFactory();
    F = FF->getApple();
    F->sayname();
    F = FF->getBanana();
    F->sayname();
    return 0;
}