常用设计模式

最新推荐文章于 2023-06-10 18:46:24 发布

qq_39477053

最新推荐文章于 2023-06-10 18:46:24 发布

阅读量133

点赞数

单例模式

简单点说，就是一个应用程序中，某个类的实例对象只有一个，你没有办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用，并不是一个新的实例，所以不要错误的理解成多个对象。单例模式实现起来也很容易，直接看demo吧

class Singleton
{
private:
Singleton() //构造函数是私有的
{
}
static Singleton *singleton;
public:
static Singleton * GetInstance()
{
if(singleton == NULL) //判断是否第一次调用
singleton = new Singleton();

return singleton;

}
};

观察者模式

意图：

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

动机：

将一个系统设计成一系列相互协作的类有一个常见的副作用：需要维护相关对象之间的一致性。

观察者模式定义一种交互，即发布-订阅：

一个对象当自身状态发生改变时，会发出通知，但是并不知道谁是他的接收者，但每个接收者都会接收到通知，这些接受者称为观察者。
作为对通知的响应，每个观察者都将查询目标状态，然后改变自身的状态以和目标状态进行同步。

使用场景：

使对象封装为独立的改变和使用；
一个对象改变同时需要改变其它对象，而不知道具体有多少对象需要改变；
不希望对象是紧耦合的。

结构：

参与者：

Subject：目标，知道它的观察者，提供注册和删除观察者对象的接口

Observer：观察者，为那些在目标发生改变时需获得通知的对象定义一个更新接口

ConcreteSubject：具体目标，存储对象状态，状态改变时，向各个观察者发出通知

ConcreteObserver：具体观察者，维护一个指向ConcreteSubject对象的引用，存储有关状态，实现更新接口update，使自身状态与目标的状态保持一致

优缺点：

1 目标和观察者之间松耦合

2 支持广播通信：Subject发送的通知不需要指定它的接受者。通知被自动广播给所有已向该目标对象登记的有关对象。

3 意外的更新：看似无害的操作可能会引起观察者错误的更新。

示例代码：

  1 /*
  2  * 观察者模式
  3  * 情景：高数课，ABCD四位同学，A是好学生，去上课，B在寝室睡觉，C在网吧打游戏，D在学校外陪女友逛街
  4  * 他们约定，如果要点名了，A在QQ群里吼一声，他们立刻赶到教室去。
  5  * 采用观察者模式实现这个情景的应用。
  6  */
  7 
  8 #include <iostream>
  9 #include <string>
 10 #include <list>
 11 
 12 class Observer;
 13 
 14 class Subject{
 15 public:
 16     virtual ~Subject() {};
 17     virtual void registerObsvr(Observer* obsvr) = 0;
 18     virtual void removeObsvr(Observer* obsvr) = 0;
 19     virtual void notifyObsvrs(const std::string &msg) = 0;
 20 };
 21 class Observer {
 22 public:
 23     virtual ~Observer() {};
 24     virtual void Update(const std::string &msg)= 0;
 25     virtual std::string getName() = 0;
 26 protected:
 27     Observer(){};
 28 };
 29 
 30 // -------------------------------------------------
 31 class QQGroup : public Subject {
 32 public:
 33     QQGroup() { _observers = new std::list<Observer*>(); }
 34     void registerObsvr(Observer* obsvr);
 35     void removeObsvr(Observer* obsvr);
 36     void notifyObsvrs(const std::string &msg);
 37 private:
 38     std::list<Observer*> *_observers;
 39 };
 40 
 41 void QQGroup::registerObsvr(Observer* obsvr) {
 42     _observers->push_back(obsvr);
 43 }
 44 
 45 void QQGroup::removeObsvr(Observer* obsvr) {
 46     if (_observers->size() > 0)
 47         _observers->remove(obsvr);
 48 }
 49 void QQGroup::notifyObsvrs( const std::string &msg) {
 50     std::cout << "群消息：" << msg << std::endl;
 51     std::list<Observer*>::iterator iter
 52         = _observers->begin();
 53     for ( ;iter != _observers->end(); iter++ ) {
 54         (*iter)->Update(msg);
 55     }
 56 }
 57 
 58 // ------------------------------------------------
 59 class RoomMate : public Observer {
 60 public:
 61     RoomMate(std::string name, std::string now ,std::string action)
 62     {
 63         _name = name;
 64         _action = action;
 65         _now = now;
 66     };
 67     void Update( const std::string &msg);
 68     std::string getName();
 69 private:
 70     std::string _name;
 71     std::string _action;
 72     std::string _now;
 73 };
 74 
 75 std::string RoomMate::getName() {
 76     return _name;
 77 }
 78 
 79 void RoomMate::Update(const std::string &msg) {
 80     std::cout<< "This is " << _name << std::endl;
 81     if ( msg == "点名了" )
 82         std::cout << "Action: " << _action
 83         << std::endl << std::endl;
 84     else
 85         std::cout << "Go on：" << _now
 86         << std::endl << std::endl ;
 87 }
 88 
 89 //测试代码
 90 int main()
 91 {
 92     RoomMate* B = new RoomMate("B",
 93         "sleeping",
 94         "get dressed and run to classroom");
 95     RoomMate* C = new RoomMate("C",
 96         "playing games",
 97         "pay the fee and run to classroom");
 98     RoomMate* D = new RoomMate("D",
 99         "shopping with girl friend",
100         "go back to school and be worried about girl friend's angry");
101 
102     QQGroup* qqgroup = new QQGroup();
103     qqgroup->registerObsvr(B);
104     qqgroup->registerObsvr(C);
105     qqgroup->registerObsvr(D);
106 
107     qqgroup->notifyObsvrs("目前没点名");
108     qqgroup->notifyObsvrs("点名了");
109 
110     system("Pause");
111     return 0;
112 }

运行截图

工厂模式

1：简单工厂模式

　　简单工厂模式是属于创建型模式，又叫做静态工厂方法(static Factory Method)模式，简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例.

　　简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。打个比方

　　假设有一个工厂，他能生产出A、B两种产品。当客户需要产品的时候一定要告诉工厂是哪种产品，是A还是B。当新增加一种新产品的时候，那么就要去修改工厂的类。　

 1 // Factory.cpp : 定义控制台应用程序的入口点。
 2 //
 3 
 4 #include "stdafx.h"
 5 #include<iostream>
 6 
 7 using namespace std;
 8 
 9 class Product
10 {
11 public:
12     virtual void show() = 0;  
13 };
14 
15 class Product_A : public Product
16 {
17 public:
18     void show()
19     {
20         cout << "Product_A" << endl;
21     }
22 };
23 
24 class Product_B : public Product
25 {
26 public:
27     void show()
28     {
29         cout << "Product_B" << endl;
30     }
31 };
32 
33 class Factory
34 {
35 public:
36     Product* Create(int i)
37     {
38         switch (i)
39         {
40         case 1:
41             return new Product_A;
42             break;
43         case 2:
44             return new Product_B;
45             break;
46         default:
47             break;
48         }
49     }
50 };
51 
52 int main()
53 {
54     Factory *factory = new Factory();
55     factory->Create(1)->show();
56     factory->Create(2)->show();
57     system("pause");
58     return 0;
59 }

二：工厂方法模式：

　　上面的简单工厂模式的缺点是当新增产品的时候就要去修改工厂的类，这就违反了开放封闭原则，(类、模块、函数)可以扩展，但是不可以修改，于是，就出现了工厂方法模式。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。打个比方

现在有A、B两种产品，那么就开两个工厂。工厂A负责生产A产品，工厂B负责生产B种产品。这时候客户不需要告诉工厂生产哪种产品了，只需要告诉工厂生产就可以了。

 1 #include "stdafx.h"
 2 #include<iostream>
 3 
 4 using namespace std;
 5 
 6 class Product
 7 {
 8 public:
 9     virtual void show() = 0;  
10 };
11 
12 class Product_A : public Product
13 {
14 public:
15     void show()
16     {
17         cout << "Product_A" << endl;
18     }
19 };
20 
21 class Product_B : public Product
22 {
23 public:
24     void show()
25     {
26         cout << "Product_B" << endl;
27     }
28 };
29 
30 class Factory
31 {
32 public:
33     virtual Product* create() = 0;
34 };
35 
36 class Factory_A : public Factory
37 {
38 public:
39     Product* create()
40     {
41         return new Product_A;
42     }
43 };
44 
45 class Factory_B : public Factory
46 {
47 public:
48     Product* create()
49     {
50         return new Product_B;
51     }
52 };
53 
54 int main()
55 {
56     Factory_A* productA = new Factory_A();
57     Factory_B* productB = new Factory_B();
58 
59     productA->create()->show();
60     productB->create()->show();
61     system("pause");
62     return 0;
63 }

抽象工厂模式

　　为什么要有抽象工厂模式，假如我们A产品中有A1和A2两种型号的产品，B产品中有B1和B2两种型号的产品，那怎么办，上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设两家工厂，工厂A负责生产A1 、A2型号产品，B工厂负责生产B1、B2型号的产品。

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用性：一个系统要独立于它的产品的创建、组合和表示时。一个系统要由多个产品系列中的一个来配置时。当你要强调一系列相关的产品对象的设计以便进行联合使用时。当你提供一个产品类库，而只想显示它们的接口而不是实现时。

 1 #include <iostream>    
 2 using namespace std;  
 3   
 4 //定义抽象类  
 5 class product1  
 6 {  
 7 public:  
 8     virtual void show() = 0;  
 9 };  
10   
11 //定义具体类  
12 class product_A1 :public product1  
13 {  
14 public:  
15     void show(){ cout << "product A1" << endl; }  
16 };  
17   
18 class product_B1 :public product1  
19 {  
20 public:  
21     void show(){ cout << "product B1" << endl; }  
22 };  
23   
24 //定义抽象类  
25 class product2  
26 {  
27 public:  
28     virtual void show() = 0;  
29 };  
30   
31 //定义具体类  
32 class product_A2 :public product2  
33 {  
34 public:  
35     void show(){ cout << "product A2" << endl; }  
36 };  
37   
38 class product_B2 :public product2  
39 {  
40 public:  
41     void show(){ cout << "product B2" << endl; }  
42 };  
43   
44   
45 class Factory  
46 {  
47 public:  
48     virtual product1 *creat1() = 0;  
49     virtual product2 *creat2() = 0;  
50 };  
51   
52 class FactoryA  
53 {  
54 public:  
55     product1 *creat1(){ return new product_A1(); }  
56     product2 *creat2(){ return new product_A2(); }  
57 };  
58   
59 class FactoryB  
60 {  
61 public:  
62     product1 *creat1(){ return new product_B1(); }  
63     product2 *creat2(){ return new product_B2(); }  
64 };  
65   
66 int main()  
67 {  
68     FactoryA *factoryA = new FactoryA();  
69     factoryA->creat1()->show();  
70     factoryA->creat2()->show();  
71   
72     FactoryB *factoryB = new FactoryB();  
73     factoryB->creat1()->show();  
74     factoryB->creat2()->show();  
75   
76     return 0;  
77 }

qq_39477053

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用设计模式

单例模式简单点说，就是一个应用程序中，某个类的实例对象只有一个，你没有办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用，并不是一个新的实例，所以不要错误的理解成多个对象。单例模式实现起来也很容易，直接看demo吧class Singleton { private: Singl...
复制链接

扫一扫