创建型模式：创建对象的机制，从所需要实例化的对象中解耦。主要分成了五种设计模式，即工厂方法、抽象工厂、生成器、原型、单例。
工厂方法
问题：一个物流公司最初只使用卡车运输，现需要增加轮船运输业务。目前的程序代码与卡车关联。
解决方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
uml类图
测试代码：
#include <iostream>
using namespace std;
//产品的接口
class Transport
{
public:
virtual ~Transport() {};
virtual void deliver() const = 0;
};
//产品A
class Truck :public Transport
{
public:
void deliver() const override
{
std::cout << "卡车运输中ing\n";
}
};
//产品B
class Ship :public Transport
{
public:
void deliver() const override
{
std::cout << "轮船运输中ing\n";
}
};
//创造者
class Logistics
{
public:
virtual ~Logistics() {};
virtual Transport* factoryMethod() const = 0;
void doSomething()
{
Transport* transport = factoryMethod();
transport->deliver();
delete transport;
}
};
//具体的创造者A
class TruckLogistis :public Logistics {
public:
virtual ~TruckLogistis() {}
virtual Transport* factoryMethod() const override {
return new Truck();
}
};
//具体的创造者B
class ShipLogistis :public Logistics {
public:
virtual ~ShipLogistis() {}
virtual Transport* factoryMethod() const override {
return new Ship();
}
};
int main()
{
Logistics* truckLogistics = new TruckLogistis();
Logistics* shipLogistics = new ShipLogistis();
truckLogistics->doSomething();
truckLogistics->doSomething();
shipLogistics->doSomething();
shipLogistics->doSomething();
shipLogistics->doSomething();
delete truckLogistics;
delete shipLogistics;
return 0;
}
缺点：应用工厂方法模式需要引入许多新的子类，代码可能会因此 变得更复杂。最好的情况是将该模式引入创建者类的现有层次结构中。
抽象工厂
问题：家具店里有沙发、椅子、茶几等产品。产品有不同风格，如现代、北欧、工业。希望确保客户收到的产品风格统一，并可以方便的添加新产品和风格。
解决方案：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
uml图
测试代码：
#include <iostream>
using namespace std;
class Chair
{
public:
virtual~Chair() {};
virtual void sitOn() const = 0;
};
class ModernChair :public Chair
{
public:
virtual~ModernChair() {};
void sitOn() const override
{
std::cout << "可以被坐下的ModernChair\n";
}
};
class ChineseChair :public Chair
{
public:
virtual~ChineseChair() {};
void sitOn() const override
{
std::cout << "可以被坐下的ChineseChair\n";
}
};
class Table
{
public:
virtual~Table() {};
virtual void putOn() const = 0;
};
class ModernTable :public Table
{
public:
virtual~ModernTable() {};
void putOn() const override
{
std::cout << "ModernTable可以放东西\n";
}
};
class ChineseTable :public Table
{
public:
virtual~ChineseTable() {};
void putOn() const override
{
std::cout << "ChineseTable可以放东西\n";
}
};
class FurnitureFacotry {//抽象工厂
public:
virtual Chair* createChair() const = 0;
virtual Table* createTable() const = 0;
};
class ModernStyleFactory :public FurnitureFacotry {
public:
Chair* createChair() const override
{
return new ModernChair();
}
Table* createTable() const override
{
return new ModernTable();
}
};
class ChineseStyleFactory :public FurnitureFacotry {
public:
Chair* createChair() const override
{
return new ChineseChair();
}
Table* createTable() const override
{
return new ChineseTable();
}
};
class Client
{
private:
FurnitureFacotry* m_furniturefactory;
public:
Client(FurnitureFacotry* furniturefactory)
{
setFactory(furniturefactory);
}
void buyFurniture()
{
Chair* chair = m_furniturefactory->createChair();
Table* table = m_furniturefactory->createTable();
chair->sitOn();
table->putOn();
delete chair;
delete table;
}
void setFactory(FurnitureFacotry* furniturefactory)
{
m_furniturefactory = furniturefactory;
}
};
int main()
{
ModernStyleFactory modernFactory;
Client client(&modernFactory);
client.buyFurniture();
ChineseStyleFactory chineseFactory;
client.setFactory(&chineseFactory);
client.buyFurniture();
return 0;
}
缺点：在产品族中扩展新的产品需要修改抽象工厂的接口代码。
生成器
问题：1、构造一个房屋，需要考虑是否有车库，游泳池，花园，雕塑等，需要对诸多成员变量进行初始化工作。都写在构造函数里？每种可能都创建一个新的类？2、相同的步骤需要能够产生不同的产品，例如使用木头和玻璃盖出来的是普通住房。用黄金和水晶建造出来的是宫殿。
解决方案：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。即将对象构造代码从产品类中抽取出来，并将其放在一个名为Builder的独立对象中。
uml类图
测试代码：
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class SimpleHouse
{
public:
std::vector<std::string> m_parts;
void printParts() const
{
std::cout << "SimpleHouse 包括：\n";
for (int i = 0; i < m_parts.size(); i++)
{
std::cout << m_parts[i] << std::endl;
}
std::cout << "-----------------------------------\n";
}
};
class Builder
{
public:
virtual ~Builder() {};
virtual void reset() = 0;
virtual void makeBaseHouse() = 0;
virtual void makeGarage() = 0;
virtual void makePool() = 0;
};
class SimpleHouseBuilder :public Builder
{
private:
SimpleHouse* m_sh;
public:
SimpleHouseBuilder()
{
reset();
}
~SimpleHouseBuilder()
{
if (m_sh)delete m_sh;
}
void reset() override
{
m_sh = new SimpleHouse;
}
void makeBaseHouse() override
{
m_sh->m_parts.push_back("BaseHouse");
}
void makeGarage() override
{
m_sh->m_parts.push_back("Garage");
}
void makePool() override
{
m_sh->m_parts.push_back("Pool");
}
SimpleHouse* getResult()
{
SimpleHouse* result = m_sh;
reset();
return result;
}
};
//主管：负责流程
class Director
{
private:
Builder* m_builder;
public:
void setBuilder(Builder* builder)
{
m_builder = builder;
}
void makeSimpleHouse()
{
m_builder->makeBaseHouse();
m_builder->makeGarage();
}
void makeFullFuncHouse()
{
m_builder->makeBaseHouse();
m_builder->makeGarage();
m_builder->makePool();
}
};
void client(Director* director)
{
std::cout << "客户自己设计流程.." << std::endl;
SimpleHouseBuilder* shb = new SimpleHouseBuilder;
shb->makeBaseHouse();
shb->makeGarage();
SimpleHouse* sh = shb->getResult();
sh->printParts();
delete sh;
std::cout << "主管负责设计流程.." << std::endl;
director->setBuilder(shb);
director->makeFullFuncHouse();
sh = shb->getResult();
sh->printParts();
delete sh;
delete shb;
}
int main()
{
Director dir;
client(&dir);
return 0;
}
缺点：如果产品之间的差异性很大，则不适合使用建造者模式，使用范围受到一定的限制。
原型
问题：希望复制一个状态完全相同的对象。首先，新建一个相同类的对象。 然后，复制所有成员变量。 但是，有时候不知道具体类型，而且成员变量可能是私有的。（从外部复制对象并非总是可行的）
解决方案：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。即复制已有对象，而无需使代码依赖他们所属的类。
uml类图
测试代码：
#include <iostream>
#include <unordered_map>
using namespace std;
enum Type
{
ROBOT_CAT = 0,
ROBOT_DOG
};
class Robot
{
protected:
std::string m_prototype_name = "";
float m_stateOfCharge = 0;
public:
virtual ~Robot() {};
Robot(std::string prototype_name) :m_prototype_name(prototype_name) {}
virtual Robot* clone()const = 0;
virtual void setStateOfCharge(float) = 0;
};
class RobotCat :public Robot
{
private:
float m_catValue;
public:
RobotCat(std::string name,float value) :Robot(name), m_catValue(value) {}
Robot* clone()const
{
return new RobotCat(*this);
}
void setStateOfCharge(float value)
{
m_stateOfCharge = value;
std::cout << "--" << m_prototype_name << " 当前电量：" << m_stateOfCharge
<< ",m_CatValue:" << m_catValue << std::endl;
}
};
class RobotDog :public Robot
{
private:
float m_dogValue;
public:
RobotDog(std::string name,float value) :Robot(name), m_dogValue(value) {}
Robot* clone()const
{
return new RobotDog(*this);
}
void setStateOfCharge(float value)
{
m_stateOfCharge = value;
std::cout << "--" << m_prototype_name << " 当前电量：" << m_stateOfCharge
<< ",m_dogValue:" << m_dogValue << std::endl;
}
};
class cloneFactory
{
private:
std::unordered_map<Type, Robot*> m_prototypes;
public:
cloneFactory()
{
m_prototypes[ROBOT_CAT] = new RobotCat("机器猫", 5.0);
m_prototypes[ROBOT_DOG] = new RobotCat("机器狗", 8.0);
}
~cloneFactory()
{
delete m_prototypes[ROBOT_CAT];
delete m_prototypes[ROBOT_DOG];
}
Robot* createRobot(Type type)
{
return m_prototypes[type]->clone();
}
};
void client(cloneFactory&rf)
{
std::cout << "克隆机器猫：\n";
Robot* cloneRobot = rf.createRobot(ROBOT_CAT);
cloneRobot->setStateOfCharge(90);
delete cloneRobot;
cloneRobot = rf.createRobot(ROBOT_CAT);
cloneRobot->setStateOfCharge(80);
delete cloneRobot;
std::cout << "克隆机器狗：\n";
cloneRobot = rf.createRobot(ROBOT_DOG);
cloneRobot->setStateOfCharge(75);
delete cloneRobot;
}
int main()
{
cloneFactory rf;
client(rf);
return 0;
}
缺点：克隆包含循环引用的复杂对象可能会非常麻烦。
单例
问题：对于一些类来说，只有一个实例是很重要的。例如数据库或其共享资源的访问权限。并且这个实例需要易于被访问。
解决方案：保证一个类只有一个实例，并提供一个访问它的全局访问点。
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
class Singleton
{
private:
Singleton(std::string value) :m_value(value) {};
~Singleton() {};
std::string m_value;
public:
Singleton(Singleton& other) = delete;
void operator=(const Singleton&) = delete;
std::string value() const { return m_value; }
static Singleton* getInstance(const std::string& value);
private:
static Singleton* m_instance;
static std::mutex m_mutex;
};
std::mutex Singleton::m_mutex;
Singleton* Singleton::m_instance = nullptr;
Singleton* Singleton::getInstance(const std::string& value)
{
std::lock_guard<std::mutex> lock(m_mutex);
if (m_instance == nullptr) {
m_instance = new Singleton(value);
}
return m_instance;
//static Singleton* instance = new Singleton(value);
//return instance;
}
void cat()
{
Singleton* singleton = Singleton::getInstance("Cat");
std::cout << singleton->value() << '\n';
}
void dog()
{
Singleton* singleton = Singleton::getInstance("Dog");
std::cout << singleton->value() << '\n';
}
int main()
{
std::thread t1(cat);
std::thread t2(dog);
t1.join();
t2.join();
return 0;
}
1297
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
