目录
一、单例
C++11语法规定，局部静态变量在第一次使用时进行初始化，如果存在多线程访问的情况，需要保证其初始化是线程安全性的。
底层原理：反汇编查看C++静态局部变量 ；说白了还是锁，只不过这段代码由编译器帮忙生成。
单例代码：
class Singleton {
public:
static Singleton& getInstance()
{
static Singleton s;
return s;
}
void work()
{
cout << "I am a Singleton" << endl;
}
private:
Singleton() {}
Singleton(const Singleton&other){}
~Singleton(){}
};
二、工厂
1.简单工厂：
工厂生成产品，需要什么产品类型就传入参数。
缺点：如果新增产品，就需要修改工厂代码。
优点：简单。
class Product {
public:
virtual void show(){}
virtual ~Product() {}
};
class ProductA :public Product {
public:
void show() {
cout << "this is productA" << endl;
}
};
class ProductB :public Product {
public:
void show() {
cout << "this is productB" << endl;
}
};
class EasyFactory {
public:
static shared_ptr<Product> GetProduct(const string& type) {
if (type == "A")
{
return make_shared<ProductA>();
}
else if (type == "B")
{
return make_shared<ProductA>();
}
else {
return nullptr;
}
}
};2.工厂方法
相对于简单工厂，优点是增加产品时，不需要修改工厂代码，而是新开一个工厂。
因为存在一个抽象工厂类，所以增加产品时，也需要增加一个生产这个产品的工厂类。
class Product {
public:
virtual void show(){}
virtual ~Product() {}
};
class ProductA :public Product {
public:
void show() {
cout << "this is productA" << endl;
}
};
class ProductB :public Product {
public:
void show() {
cout << "this is productB" << endl;
}
};
class Factory {
public:
virtual shared_ptr<Product> createProduct() = 0;
virtual ~Factory() {}
};
class FactoryA :public Factory
{
public:
shared_ptr<Product> createProduct()
{
return make_shared< ProductA>();
}
};3.抽象工厂
抽象工厂通常会定义多个工厂方法，每个工厂方法用于创建一个特定类型的产品。
#include <iostream>
#include <sstream>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <thread>
#include <mutex>
#include <functional>
using namespace std;
//抽象角色
class Character {
public:
virtual void show() = 0;
};
//抽象武器
class Weapon {
public:
virtual void show()= 0;
};
//魔法世界的角色
class MagicCharacter:public Character {
public:
void show() override
{
cout << "it's magic charactor" << endl;
}
};
//魔法世界的武器
class MagicWeapon:public Weapon {
public:
void show() override
{
cout << "it's magic weapon" << endl;
}
};
//科学世界的角色
class ScienceCharacter:public Character {
public:
void show() override
{
cout << "it's science charactor" << endl;
}
};
//科学世界的武器
class ScienceWeapon:public Weapon {
public:
void show() override
{
cout << "it's science weapon" << endl;
}
};
//抽象工厂
class AbstractFactory {
public:
virtual shared_ptr<Character> createCharacter() = 0;
virtual shared_ptr<Weapon> createWeapon() = 0;
};
//魔法世界工厂
class MagicFactory {
public:
shared_ptr<Character> createCharacter()
{
return make_shared<MagicCharacter>();
}
shared_ptr<Weapon> createWeapon()
{
return make_shared<MagicWeapon>();
}
};
//科学世界工厂
class ScienceFactory {
public:
shared_ptr<Character> createCharacter()
{
return make_shared<ScienceCharacter>();
}
shared_ptr<Weapon> createWeapon()
{
return make_shared<ScienceWeapon>();
}
};
int main()
{
shared_ptr<MagicFactory> sp_mf = make_shared<MagicFactory>();
auto mc = sp_mf->createCharacter();
auto mw = sp_mf->createWeapon();
mc->show();
mw->show();
shared_ptr<ScienceFactory> sp_sf = make_shared<ScienceFactory>();
auto sc = sp_sf->createCharacter();
auto sw = sp_sf->createWeapon();
sc->show();
sw->show();
}三、观察者
对象间的一对多关系，当一个对象状态发生改变时，依赖于它的对象都会得到通知并更新状态。
可以用于：消息队列系统、事件处理系统、数据库变更通知
#include <iostream>
#include <sstream>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <thread>
#include <mutex>
#include <functional>
class Observer {
public:
virtual void update() = 0;
virtual ~Observer() {}
};
class ObserverA :public Observer {
public:
void update()
{
cout << "ObserverA update" << endl;
}
};
class ObserverB :public Observer {
public:
void update()
{
cout << "ObserverB update" << endl;
}
};
class Subject {
public:
virtual void attach(std::shared_ptr<Observer> observer) = 0;
virtual void detach(std::shared_ptr<Observer> observer) = 0;
virtual void notify() = 0;
private:
vector<std::shared_ptr<Observer>> observers;
};
class SubjectA {
public:
virtual void attach(std::shared_ptr<Observer> observer)
{
this->observers.push_back(observer);
}
virtual void detach(std::shared_ptr<Observer> observer)
{
auto it = std::find(observers.begin(), observers.end(), observer);
if (it != observers.end())
{
this->observers.erase(it);
}
}
virtual void notify()
{
for (auto &it : observers)
{
it->update();
}
}
private:
vector<std::shared_ptr<Observer>> observers;
};
int main()
{
shared_ptr<Observer> sp_OA = make_shared< ObserverA>();
shared_ptr<Observer> sp_OB = make_shared< ObserverB>();
shared_ptr<SubjectA> sp_SA = make_shared< SubjectA>();
sp_SA->attach(sp_OA);
sp_SA->attach(sp_OB);
sp_SA->notify();
sp_SA->detach(sp_OB);
sp_SA->notify();
}
四、策略模式
定义了一组算法，使得它们可以相互替代；让算法独立于使用他们的客户而独立变化。
优点：1、算法可以自由切换 2、避免使用多重条件判断 3、扩展性好。
class Strategy {
public:
virtual void exec() = 0;
virtual ~Strategy() {}
};
class StrategyA:public Strategy{
public:
void exec() override
{
cout << "exec A" << endl;
}
};
class StrategyB:public Strategy {
public:
void exec() override
{
cout << "exec B" << endl;
}
};
class Context {
private:
unique_ptr<Strategy> m_strategy;
public:
void setStrategy(unique_ptr<Strategy> strategy)
{
this->m_strategy = std::move(strategy);
}
void execStrategy()
{
if (this->m_strategy != nullptr)
{
this->m_strategy->exec();
}
else
{
cout << "Context's strategy is not set" << endl;
}
}
};
int main()
{
Context ctx;
unique_ptr<Strategy> sp_sa = make_unique< StrategyA>();
unique_ptr<Strategy> sp_sb = make_unique< StrategyB>();
ctx.setStrategy(std::move(sp_sa));
ctx.execStrategy();
ctx.setStrategy(std::move(sp_sb));
ctx.execStrategy();
return 0;
}
