淘宝搜券的网站怎么做,wordpress能静态吗,做网站应该买什么服务器,站长之家音效详细介绍设计模式
单例模式 ⼀个类只能创建⼀个对象#xff0c;即单例模式#xff0c;该设计模式可以保证系统中该类只有⼀个实例#xff0c;并提供⼀个访问它的全局访问点#xff0c;该实例被所有程序模块共享。⽐如在某个服务器程序中#xff0c;该服务器的配置信息存放…详细介绍设计模式
单例模式 ⼀个类只能创建⼀个对象即单例模式该设计模式可以保证系统中该类只有⼀个实例并提供⼀个访问它的全局访问点该实例被所有程序模块共享。⽐如在某个服务器程序中该服务器的配置信息存放在⼀个⽂件中这些配置数据由⼀个单例对象统⼀读取然后服务进程中的其他对象再通过这个单例对象获取这些配置信息这种⽅式简化了在复杂环境下的配置管理。 单例模式有两种实现模式饿汉模式和懒汉模式
饿汉模式 程序启动时就会创建⼀个唯⼀的实例对象。 因为单例对象已经确定 所以⽐较适⽤于多线程环境中 多线程获取单例对象不需要加锁 可以有效的避免资源竞争 提⾼性能。 // 饿汉模式
templatetypename T
class Singleton {
private:static Singleton _eton;
private:Singleton(){}~Singleton(){}
public:Singleton(const Singleton) delete;Singleton operator(const Singleton) delete;static T getInstance() {return _eton;}
};
Singleton Singleton::_eton; 懒汉模式 第⼀次使⽤要使⽤单例对象的时候创建实例对象。如果单例对象构造特别耗时或者耗费济源(加载插件、加载⽹络资源等) 可以选择懒汉模式 在第⼀次使⽤的时候才创建对象。 这⾥介绍的是《Effective C》⼀书作者 Scott Meyers 提出的⼀种更加优雅简便的单例模式Meyers’ Singleton in C。 C11 Static local variables 特性以确保C11起静态变量将能够在满⾜ thread-safe 的前提下唯⼀地被构造和析构 // 懒汉模式
template typename T
class Singleton {
private:Singleton(){}~Singleton(){}
public: Singleton(const Singleton) delete;Singleton operator(const Singleton) delete;static T getInstance() { static Singleton _eton;return _eton; }
};工厂模式
⼯⼚模式是⼀种创建型设计模式 它提供了⼀种创建对象的最佳⽅式。在⼯⼚模式中我们创建对象时不会对上层暴露创建逻辑⽽是通过使⽤⼀个共同结构来指向新创建的对象以此实现创建-使⽤的分离。 工厂模式可以分为:简单工厂模式工厂方法模式抽象工厂模式。
简单工厂模式 简单⼯⼚模式实现由⼀个⼯⼚对象通过类型决定创建出来指定产品类的实例。假设有个⼯⼚能⽣产出⽔果当客⼾需要产品的时候明确告知⼯⼚⽣产哪类果⼯⼚需要接收⽤⼾提供的类别信息当新增产品的时候⼯⼚内部去添加新产品的⽣产⽅式。 //简单⼯⼚模式通过参数控制可以⽣产任何产品
// 优点简单粗暴直观易懂。使⽤⼀个⼯⼚⽣产同⼀等级结构下的任意产品
// 缺点
// 1. 所有东西⽣产在⼀起产品太多会导致代码量庞⼤
// 2. 开闭原则遵循(开放拓展关闭修改)的不是太好要新增产品就必须修改⼯⼚⽅法。
#include iostream
#include string
#include memory
class Fruit {public:Fruit(){}virtual void show() 0;
};
class Apple : public Fruit {public:Apple() {}virtual void show() {std::cout 我是⼀个苹果 std::endl;}
};
class Banana : public Fruit {public:Banana() {}virtual void show() {std::cout 我是⼀个⾹蕉 std::endl;}
};
class FruitFactory {public:static std::shared_ptrFruit create(const std::string name) {if (name 苹果) {return std::make_sharedApple();}else if(name ⾹蕉) {return std::make_sharedBanana();}return std::shared_ptrFruit();}
};
int main()
{std::shared_ptrFruit fruit FruitFactory::create(苹果);fruit-show();fruit FruitFactory::create(⾹蕉);fruit-show();return 0;
}这个模式的结构和管理产品对象的⽅式⼗分简单 但是它的扩展性⾮常差当我们需要新增产品的时候就需要去修改⼯⼚类新增⼀个类型的产品创建逻辑违背了开闭原则。
工厂方法模式 在简单⼯⼚模式下新增多个⼯⼚多个产品每个产品对应⼀个⼯⼚。假设现在有 A、B 两种产品则开两个⼯⼚⼯⼚ A 负责⽣产产品 A⼯⼚ B 负责⽣产产品 B⽤⼾只知道产品 的⼯⼚名⽽不知道具体的产品信息⼯⼚不需要再接收客⼾的产品类别⽽只负责⽣产产品。 #include iostream
#include string
#include memory
//⼯⼚⽅法定义⼀个创建对象的接⼝但是由⼦类来决定创建哪种对象使⽤多个⼯⼚分别⽣产指定
的固定产品
// 优点
// 1. 减轻了⼯⼚类的负担将某类产品的⽣产交给指定的⼯⼚来进⾏
// 2. 开闭原则遵循较好添加新产品只需要新增产品的⼯⼚即可不需要修改原先的⼯⼚类
// 缺点对于某种可以形成⼀组产品族的情况处理较为复杂,需要创建⼤量的⼯⼚类.
class Fruit {public:Fruit(){}virtual void show() 0;
};
class Apple : public Fruit {public:Apple() {}virtual void show() {std::cout 我是⼀个苹果 std::endl;}private:std::string _color;
};
class Banana : public Fruit {public:Banana() {}virtual void show() {std::cout 我是⼀个⾹蕉 std::endl;}
};
class FruitFactory {public:virtual std::shared_ptrFruit create() 0;
};
class AppleFactory : public FruitFactory {public:virtual std::shared_ptrFruit create() {return std::make_sharedApple();}
};
class BananaFactory : public FruitFactory {public:virtual std::shared_ptrFruit create() {return std::make_sharedBanana();}
};
int main()
{std::shared_ptrFruitFactory factory(new AppleFactory());fruit factory-create();fruit-show();factory.reset(new BananaFactory());fruit factory-create();fruit-show();return 0;
}⼯⼚⽅法模式每次增加⼀个产品时都需要增加⼀个具体产品类和⼯⼚类这会使得系统中类的个数成倍增加在⼀定程度上增加了系统的耦合度。
抽象工厂模式 ⼯⼚⽅法模式通过引⼊⼯⼚等级结构解决了简单⼯⼚模式中⼯⼚类职责太重的问题但由于⼯⼚⽅法模式中的每个⼯⼚只⽣产⼀类产品可能会导致系统中存在⼤量的⼯⼚类势必会增加系统的开销。此时我们可以考虑将⼀些相关的产品组成⼀个产品族位于不同产品等级结构中功能相关联的产品组成的家族由同⼀个⼯⼚来统⼀⽣产这就是抽象⼯⼚模式的基本思想。 #include iostream
#include string
#include memory
//抽象⼯⼚围绕⼀个超级⼯⼚创建其他⼯⼚。每个⽣成的⼯⼚按照⼯⼚模式提供对象。
// 思想将⼯⼚抽象成两层抽象⼯⼚ 具体⼯⼚⼦类 在⼯⼚⼦类种⽣产不同类型的⼦产品
class Fruit {public:Fruit(){}virtual void show() 0;
};
class Apple : public Fruit {public:Apple() {}virtual void show() {std::cout 我是⼀个苹果 std::endl;}private:std::string _color;
};
class Banana : public Fruit {public:Banana() {}virtual void show() {std::cout 我是⼀个⾹蕉 std::endl;}
};
class Animal {public:virtual void voice() 0;
};
class Lamp: public Animal {public:void voice() { std::cout 咩咩咩\n; }
};
class Dog: public Animal {public:void voice() { std::cout 汪汪汪\n; }
};
class Factory {public:virtual std::shared_ptrFruit getFruit(const std::string name) 0;virtual std::shared_ptrAnimal getAnimal(const std::string name) 0;
};
class FruitFactory : public Factory {public:virtual std::shared_ptrAnimal getAnimal(const std::string name) {return std::shared_ptrAnimal();}virtual std::shared_ptrFruit getFruit(const std::string name) {if (name 苹果) {return std::make_sharedApple();}else if(name ⾹蕉) {return std::make_sharedBanana();}return std::shared_ptrFruit();}
};
class AnimalFactory : public Factory {public:virtual std::shared_ptrFruit getFruit(const std::string name) {return std::shared_ptrFruit();}virtual std::shared_ptrAnimal getAnimal(const std::string name) {if (name ⼩⽺) {return std::make_sharedLamp();}else if(name ⼩狗) {return std::make_sharedDog();}return std::shared_ptrAnimal();}
};
class FactoryProducer {public:static std::shared_ptrFactory getFactory(const std::string name) {if (name 动物) {return std::make_sharedAnimalFactory();}else {return std::make_sharedFruitFactory();}}
};
int main()
{std::shared_ptrFactory fruit_factory FactoryProducer::getFactory(⽔
果);std::shared_ptrFruit fruit fruit_factory-getFruit(苹果);fruit-show();fruit fruit_factory-getFruit(⾹蕉);fruit-show();std::shared_ptrFactory animal_factory FactoryProducer::getFactory(动
物);std::shared_ptrAnimal animal animal_factory-getAnimal(⼩⽺);animal-voice();animal animal_factory-getAnimal(⼩狗);animal-voice();return 0;
}抽象⼯⼚模式适⽤于⽣产多个⼯⼚系列产品衍⽣的设计模式增加新的产品等级结构复杂需要对原有系统进⾏较⼤的修改甚⾄需要修改抽象层代码违背了“开闭原则”。
建造者模式
建造者模式是⼀种创建型设计模式 使⽤多个简单的对象⼀步⼀步构建成⼀个复杂的对象能够将⼀个复杂的对象的构建与它的表⽰分离提供⼀种创建对象的最佳⽅式。主要⽤于解决对象的构建过于复杂的问题。 建造者模式主要基于四个核⼼类实现 • 抽象产品类 • 具体产品类⼀个具体的产品对象类 • 抽象Builder类创建⼀个产品对象所需的各个部件的抽象接⼝ • 具体产品的Builder类实现抽象接⼝构建各个部件 • 指挥者Director类统⼀组建过程提供给调⽤者使⽤通过指挥者来构造产品 #includeiostream
#includestring
#includememoryclass Computer//抽象电脑类
{public:Computer(){}void SetBoard(const std::string Board){_boardBoard;}void SetDisplay(const std::string Display){_displayDisplay;}virtual void SetOs()0;void showParamaters(){std::string paramComputer Paramaters:\n;param\tBoard:_board\n;param\tDisplay:_display\n;param\tOs:_os\n;std::coutparamstd::endl;}protected:std::string _board;//主板std::string _display;//显示器std::string _os;//操作系统
};class MacBook:public Computer//具体电脑类
{public: void SetOs() override{_osMac Os x12;}
};class Builder//抽象建造者类
{public: virtual void buildBoard(const std::string board)0;virtual void buildDisplay(const std::string display)0;virtual void buildOs()0;virtual std::shared_ptrComputer Build()0;
};class MacBookBuilder:public Builder//具体建造者类
{public:MacBookBuilder():_computer(new MacBook()){}void buildBoard(const std::string board){_computer-SetBoard(board);}void buildDisplay(const std::string display){_computer-SetDisplay(display);}virtual void buildOs(){_computer-SetOs();}std::shared_ptrComputer Build(){return _computer;}private:std::shared_ptrComputer _computer;//利用多态
};class Director//指挥者,产品必须按照某种顺序来生产
{public:Director(Builder* builder):_builder(builder){}void construct(const std::string board,const std::string display){//按顺序建造_builder-buildBoard(board);_builder-buildDisplay(display);_builder-buildOs();}private:std::shared_ptrBuilder _builder;};int main()
{Builder* buildernew MacBookBuilder();std::unique_ptrDirector director(new Director(builder));director-construct(英特尔,三星);std::shared_ptrComputer computerbuilder-Build();computer-showParamaters();return 0;
}代理模式 代理模式指代理控制对其他对象的访问 也就是代理对象控制对原对象的引⽤。在某些情况下⼀个对象不适合或者不能直接被引⽤访问⽽代理对象可以在客⼾端和⽬标对象之间起到中介的作⽤。 代理模式的结构包括⼀个是真正的你要访问的对象(⽬标类)、⼀个是代理对象。⽬标对象与代理对象实现同⼀个接⼝先访问代理类再通过代理类访问⽬标对象。 代理模式分为静态代理、动态代理 静态代理指的是在编译时就已经确定好了代理类和被代理类的关系。也就是说在编译时就已经确定了代理类要代理的是哪个被代理类。 动态代理指的是在运⾏时才动态⽣成代理类并将其与被代理类绑定。这意味着在运⾏时才能确定代理类要代理的是哪个被代理类。 以租房为例房东将房⼦租出去但是要租房⼦出去需要发布招租启⽰ 带⼈看房负责维修这些⼯作中有些操作并⾮房东能完成因此房东为了图省事将房⼦委托给中介进⾏租赁。 代理模式实现
/*房东要把⼀个房⼦通过中介租出去理解代理模式*/
#include iostream
#include string
class RentHouse {public:virtual void rentHouse() 0;
};
/*房东类将房⼦租出去*/
class Landlord : public RentHouse {public: void rentHouse() {std::cout 将房⼦租出去\n;}
};
/*中介代理类对租房⼦进⾏功能加强实现租房以外的其他功能*/
class Intermediary : public RentHouse {
public:void rentHouse() {std::cout 发布招租启⽰\n;std::cout 带⼈看房\n;_landlord.rentHouse();std::cout 负责租后维修\n;}private:Landlord _landlord;
};
int main()
{Intermediary intermediary;intermediary.rentHouse();return 0;
}
