文章目录
专栏导读
🌸作者简介:花想云,在读本科生一枚,C/C++领域新星创作者,新星计划导师,阿里云专家博主,CSDN内容合伙人...致力于 C/C++、Linux 学习。
🌸专栏简介:本文收录于 C++项目------基于多设计模式下的同步与异步日志系统
设计模式
是一种在软件设计中常见的可重用解决方案
的方法。它们是经过反复验证和证明
的最佳实践,可以帮助软件开发人员解决特定问题或应对常见的设计挑战。设计模式提供了一种通用的框架,有助于构建高质量、易于维护和可扩展的软件系统
。
六大原则
-
单一职责原则
类的职责应该单一,一个方法只做一件事
。职责划分清晰明了,每次改动到最小的方法或类;- 使用建议:两个完全不一样的功能不应该放在一个类中,一个类应该是一组相关性很高的函数、数据的封装;
- 用例:网络聊天:网络通信&聊天,应该分割为网络通信类或聊天类;
-
开闭原则
对扩展开放,对修改封闭
;- 使用建议:对软件实体的改动,最好使用拓展而非修改的方式;
- 用例:超市卖货:商品价格时长需要改动,但不是修改原来商品的价格而是新增促销价格;
-
里氏替换原则
- 通俗点讲,就是
只要父类能出现的地方,子类就可以出现,而且替换为子类也不会出现任何错误或异常
; - 在继承类时,务必重写父类中所有的方法,尤其需要注意父类的
protected
方法,子类尽量不要暴露自己的public
方法供外界调用; - 使用建议:子类必须完全实现父类的方法,孩子可以有自己的个性。覆盖或实现父类的方法时,输入参数可以被放大,输出可以缩小;
- 用例:跑步运动员类会跑步,子类长跑运动员会跑步且擅长长跑,子类短跑运动员会跑步且擅长短跑;
- 通俗点讲,就是
-
依赖倒置原则
高层模块不应该依赖低层模块,两者都应该依赖其抽象
。不可分割的原子逻辑就是低层模式,原子逻辑组装成的就是高层模块;模块间依赖通过抽象(接口)发生,具体类之间不之间依赖
;- 使用建议:每个类都尽量有抽象类,任何类都不应该从具体类派生。尽量不要重写基类的方法。结合里氏替换原则使用。
- 用例:奔驰车司机类只能开奔驰,司机类给什么车就开什么车,开车的人:司机------依赖于抽象;
-
迪米特法则
尽量减少对象之间的交互,从而减少类之间的耦合
。一个对象应该对其他对象有最少的了解。对类的低耦合提出了明确的要求:- 只和直接的朋友交流,朋友之间也是有距离的。自己的就是自己的(如果一个方法放在本类中,既不增加类间关系,也不产生负面影响,那就放置在本类中;
- 用例:老师让班长点名,老师给班长一个名单,班长点完名勾选,返回结果,而不是班长点名,老师勾选;
-
接口隔离原则
客户端不应该依赖他不需要的接口,类间的依赖关系应该建立在最小的接口上
;- 使用建议:接口设计尽量精简单一,但是不要对外暴露没有实际意义的接口;
- 用例:修改密码:不应该提供修改用户信息接口,而就是单一的最小修改密码的接口;
从整体上来了解六大原则,可以简要的概括为一句话:用抽象构建框架,用实现拓展细节
。具体到每一条设计原则,则对应一条注意事项:
单一职责
原则告诉我们实现类要职责单一
;里氏替换
原则告诉我们不要破坏继承体系
;依赖倒置
原则告诉我们要面向接口编程
;接口隔离
原则告诉我们在设计接口时要降低耦合
;开闭原则是总纲
,告诉我们要对拓展开放,对修改关闭
;
单例模式
一个类只能创建⼀个对象
,即单例模式
,该设计模式可以保证系统中该类只有一个实例,并提供⼀个访问它的全局访问点,该实例被所有程序模块共享。- 比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由⼀个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式:饿汉模式和懒汉模式。
饿汉模式
程序启动时就会创建一个唯一的实例对象
。因为单例对象已经确定,所以比较适用于多线程环境中,多线程获取单例对象不需要加锁
,可以有效的避免资源竞争,提高性能
。
cpp
#include <iostream>
#include <string>
// 饿汉模式
class Singleton
{
public:
Singleton(const Singleton &) = delete;
Singleton& operator=(const Singleton&) = delete;
static Singleton& getInstance()
{
return _eton;
}
std::string &getData()
{
return _data;
}
private:
Singleton() :_data("Singleton")
{
std::cout << "获取单例对象" <<std::endl;
}
~Singleton() {}
private:
static Singleton _eton;
std::string _data;
};
Singleton Singleton::_eton;
int main()
{
std::cout << Singleton::getInstance().getData() << std::endl;
return 0;
}
懒汉模式
第一次要使用单例对象的时候创建实例对象
。如果单例对象构造特别耗时或者耗费资源(加载插件、加载网络资源等),可以选择懒汉模式,在第一次使用的时候才创建对象。C++11后,静态变量能够满足在线程安全的前提下唯一的被构造和析构
;
cpp
// 懒汉模式
class Singleton
{
public:
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
static Singleton &getInstance()
{
static Singleton _eton;
return _eton;
}
std::string &getData()
{
return _data;
}
private:
Singleton() : _data("Singleton")
{
std::cout << "单例对象构造" << std::endl;
}
~Singleton() {}
private:
static Singleton _eton;
std::string _data;
};
工厂模式
- 工厂模式是一种创建型设计模式,它提供了一种创建对象的最佳方式。
在工厂模式中,我们创建对象时不会对上层暴露创建逻辑,而是通过使用一个共同结构来指向新创建的对象,以此实现创建与使用的分离
。
工厂模式可以分为:
- 简单工厂模式;
- 工厂方法模式;
- 抽象工厂模式;
简单工厂模式
- 简单工厂模式实现
由一个工厂对象通过类型来决定创建出来指定产品类的实例
。 - 假设有个工厂能生产出水果,当客户生产水果的时候明确告诉工厂生产哪类水果,工厂需要接收用户提供的类别信息,当新增产品的时候,工厂内部去添加新产品的生产方式。
cpp
/*
简单工厂模式:通过参数控制可以生产任何商品
优点:简单粗暴、直观易懂。使用一个工厂生产同一等级结构下的任意商品
缺点:
1.所有东西生产在一起,产品太多会导致代码量庞大;
2.开闭原则遵守不是太好,要新增产品就必须修改工厂方法。
*/
#include <iostream>
class Fruit
{
public:
Fruit() {}
virtual void name() = 0;
};
class Apple : public Fruit
{
public:
Apple() {}
virtual void name()
{
std::cout << "苹果" << std::endl;
}
};
class Banana : public Fruit
{
public:
Banana() {}
virtual void name()
{
std::cout << "香蕉" << std::endl;
}
};
class FruitFactory
{
public:
static std::shared_ptr<Fruit> create(const std::string &name)
{
if (name == "苹果")
return std::make_shared<Apple>();
else if (name == "香蕉")
return std::make_shared<Banana>();
return std::shared_ptr<Fruit>();
}
};
int main()
{
std::shared_ptr<Fruit> ff = FruitFactory::create("苹果");
ff->name();
ff = FruitFactory::create("香蕉");
ff->name();
return 0;
}
工厂方法模式
在简单工厂模式下新增多个工厂,多个产品,每个产品对应一个工厂
。- 假设现在有A、B两种产品,则开两个工厂,工厂A负责生产产品A,工厂B负责生产产品B,用户只知道产品的工厂名,而不知道具体的产品信息,工厂不需要再接收客户的产品类别,而只负责生产产品。
cpp
/*
工厂方法模式:定义一个创建对象的接口,但是由子类来决定创建哪种对象,使用多个工厂分别生产指定的固定产品
优点:
1.减轻了工厂类的负担,将某产品的生产交给指定的工厂来进行;
2.开闭原则遵循较好,添加新产品只需要新增产品的工厂即可,不需要修改原先的工厂类。
缺点:
对于某种可以形成一组产品族的情况处理较为复杂,需要创建大量的工厂类。
*/
#include <iostream>
#include <string>
#include <memory>
class Fruit
{
public:
Fruit() {}
virtual void name() = 0;
};
class Apple : public Fruit
{
public:
Apple() {}
virtual void name()
{
std::cout << "苹果" << std::endl;
}
private:
std::string _color;
};
class Banana : public Fruit
{
public:
Banana() {}
virtual void name()
{
std::cout << "香蕉" << std::endl;
}
};
class FruitFactory
{
public:
virtual std::shared_ptr<Fruit> create() = 0;
};
class AppleFactory : public FruitFactory
{
public:
virtual std::shared_ptr<Fruit> create()
{
return std::make_shared<Apple>();
}
};
class BananaFactory : public FruitFactory
{
public:
virtual std::shared_ptr<Fruit> create()
{
return std::make_shared<Banana>();
}
};
int main()
{
std::shared_ptr<FruitFactory> factory(new AppleFactory());
std::shared_ptr<Fruit> fruit = factory->create();
fruit->name();
factory.reset(new BananaFactory());
fruit = factory->create();
fruit->name();
return 0;
}
抽象工厂模式
- 工厂方法模式通过引入工厂等级结构,解决了简单工厂模式中工厂职责太重的问题,但由于工厂方法模式中的每个工厂只生产一类产品,
可能会导致系统中存在大量的工厂类,势必会增加系统的开销
。此时,我们可以考虑将一些相关的产品组成一个产品族
(位于不同产品等级结构中功能相关联的产品组成的家族),由同一个工厂来统一生产
,这就是抽象工厂模式的基本思想。
cpp
/*
抽象工厂:围绕一个超级工厂去创建其他工厂。每个生成的工厂按照工厂模式提供对象。
思想:将工厂抽象成两层,抽象工厂 & 具体工厂子类,在工厂子类中生产不同类型的子产品
*/
#include <iostream>
#include <string>
#include <memory>
class Fruit
{
public:
Fruit() {}
virtual void name() = 0;
};
class Apple : public Fruit
{
public:
Apple() {}
void name() override
{
std::cout << "苹果" << std::endl;
}
private:
std::string _color;
};
class Banana : public Fruit
{
public:
Banana() {}
void name() override
{
std::cout << "香蕉" << std::endl;
}
};
class Animal
{
public:
virtual void voice() = 0;
};
class Cat : public Animal
{
public:
void voice() override
{
std::cout << "喵喵喵" << std::endl;
}
};
class Dog : public Animal
{
public:
void voice() override
{
std::cout << "汪汪汪" << std::endl;
}
};
class Factory
{
public:
virtual std::shared_ptr<Fruit> getFruit(const std::string &name) = 0;
virtual std::shared_ptr<Animal> getAnimal(const std::string &name) = 0;
};
class FruitFactory : public Factory
{
public:
std::shared_ptr<Animal> getAnimal(const std::string &name) override
{
return std::shared_ptr<Animal>();
}
std::shared_ptr<Fruit> getFruit(const std::string &name) override
{
if (name == "苹果")
return std::make_shared<Apple>();
else if (name == "香蕉")
return std::make_shared<Banana>();
return std::shared_ptr<Fruit>();
}
};
class AnimalFactory : public Factory
{
public:
std::shared_ptr<Fruit> getFruit(const std::string &name) override
{
return std::shared_ptr<Fruit>();
}
std::shared_ptr<Animal> getAnimal(const std::string &name) override
{
if (name == "小猫")
return std::make_shared<Cat>();
else if (name == "小狗")
return std::make_shared<Dog>();
return std::shared_ptr<Animal>();
}
};
class FactoryProducer
{
public:
static std::shared_ptr<Factory> getFactory(const std::string &name)
{
if (name == "水果")
return std::make_shared<FruitFactory>();
else if(name == "动物")
return std::make_shared<AnimalFactory>();
}
};
int main()
{
std::shared_ptr<Factory> fruit_factory = FactoryProducer::getFactory("水果");
std::shared_ptr<Fruit> fruit = fruit_factory->getFruit("苹果");
fruit->name();
fruit = fruit_factory->getFruit("香蕉");
fruit->name();
std::shared_ptr<Factory> animal_factory = FactoryProducer::getFactory("动物");
std::shared_ptr<Animal> animal = animal_factory->getAnimal("小猫");
animal->voice();
animal = animal_factory->getAnimal("小狗");
animal->voice();
return 0;
}
建造者模式
- 建造者模式是一种
创建型设计模式
,使用多个简单的对象一步一步构建出一个复杂的对象,能够将一个复杂的对象的构建与它的表示分离,提供一种创建对象的最佳方式
。主要用于解决对象的构建过于复杂的问题。
建造者模式主要基于4个核心类实现:
- 抽象产品类;
- 具体产品类:一个具体的产品对象类;
- 抽象pubic类:创建一个产品对象所需的各个部件的抽象接口;
- 具体产品的Builder类:实现抽象接口,构建各个部件;
- 指挥者Director类:统一组建过程,提供给调用者使用,通过指挥者来构建产品;
cpp
#include <iostream>
#include <memory>
/* 抽象电脑类 */
#include <iostream>
#include <memory>
class Computer
{
public:
using ptr = std::shared_ptr<Computer>;
Computer() {};
void setBoard(const std::string &board) { _board = board ;}
void setDisplay(const std::string &display) {_display = display;}
virtual void setOs() = 0;
std::string show()
{
std::string computer = "Computer:[\n";
computer += "\tboard: " + _board + "\n";
computer += "\tdisplay: " + _display + "\n";
computer += "\tos: " + _os + "\n";
computer += "]\n";
return computer;
}
protected:
std::string _board;
std::string _display;
std::string _os;
};
/* 具体产品类 */
class MacBook : public Computer
{
public:
using ptr = std::shared_ptr<MacBook>;
MacBook() {}
virtual void setOs()
{
_os = "Mac Os X12";
}
};
/* 抽象建造者类:包含创建一个产品对象各个部件的抽象接口 */
class Builder
{
public:
using ptr = std::shared_ptr<Builder>;
virtual void buildBoard(const std::string &board) = 0;
virtual void buildDisplay(const std::string &display) = 0;
virtual void buildOS() = 0;
virtual Computer::ptr build() = 0;
};
/* 具体产品的具体建造者类:实现抽象接口,构建和组装各个部件 */
class MacBookBuilder : public Builder
{
public:
using ptr = std::shared_ptr<MacBookBuilder>;
MacBookBuilder() : _computer(new MacBook()) {}
virtual void buildBoard(const std::string &board)
{
_computer->setBoard(board);
}
virtual void buildDisplay(const std::string &display)
{
_computer->setDisplay(display);
}
virtual void buildOS()
{
_computer->setOs();
}
virtual Computer::ptr build()
{
return _computer;
}
private:
Computer::ptr _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:
Builder::ptr _builder;
};
int main()
{
Builder* builder = new MacBookBuilder();
std::unique_ptr<Director> pd(new Director(builder));
pd->construct("华为主板", "VOC显示器");
Computer::ptr computer = builder->build();
std::cout << computer->show() ;
return 0;
}
代理模式
-
代理模式指
代理控制对其他对象的访问,也就是代理对象控制对原对象的引用
。在某些情况下,一个对象不能或不适合直接被引用访问,而代理对象可以在客户端与目标对象之间起到中介作用
。 -
代理模式的结构包括一个真正的你要访问的对象(目标类)、一个是代理对象。目标对象与代理对象实现同一个接口,先访问代理类,再通过代理类来访问目标对象。代理模式分为静态代理、动态代理:
-
静态代理
指的是:在编译时就已经确定好了代理类和被代理类的关系。也就是说,在编译时就已经确定了代理类要代理的是哪一个类。 -
动态代理
指的是:在运行时才动态生产代理类,并将其与被代理类绑定。这意味着在运行时才能确定代理类要代理的是哪一个类。
-
以租房为例,房东将房子租出去,但是房子要租出去,需要发布招租启示,带人看房,负责维修,这些操作中有些操作并非房东能完成,因此房东为了图省事,将房子委托给中介进行租赁。
cpp
#include <iostream>
#include <string>
/*房东要把⼀个房⼦通过中介租出去理解代理模式*/
/* 租房类 */
class RentHouse
{
public:
virtual void rentHouse() = 0;
};
/* 房东类 */
class Landlord : public RentHouse
{
public:
void rentHouse()
{
std::cout << "将房子租出去\n" << std::endl;
}
};
/* 中介类 */
class Intermedirary : public RentHouse
{
public:
void rentHouse()
{
std::cout << "发布告示" << std::endl;
std::cout << "带人看房" << std::endl;
_landlord.rentHouse();
std::cout << "负责租后维修" << std::endl;
}
private:
Landlord _landlord;
};
int main()
{
Intermedirary intermedirary;
intermedirary.rentHouse();
return 0;
}