C++ 与设计模式学习（其一）

记得曾经一年前，听到同学再说设计模式，当时觉得不怎么重要，所以就没有去系统的学习，这一放，就是一年，直到前段时间，面试了一个阿里巴巴的职位，要我谈谈对于设计模式的看法。

之后就好好了看了一些文章，好好的体会了一番！现在将自己的心得好好的分享一下吧！(由于设计模式内容比较多，以及设计模式的六大原则，后续都会陆续的更新!)

1. 单例模式（单件模式）：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。

　　举个栗子：

 1 #include<iostream>
 2 
 3 class sigle_class {
 4 
 5 private :
 6 
 7     sigle_class() {};  //将构造函数私有化
 8     static sigle_class * sigle; 
 9 
10 public:
11     ~sigle_class();
12     static sigle_class * init();
13     void  show() {
14         std::cout <<"这是一个单例模式"<<std::endl;
15     }
16 };
17 
18 //对于静态变量需要在内外进行必要的初始化！
19 sigle_class * sigle_class::sigle = NULL;
20 
21 sigle_class::~sigle_class() {
22 
23     std::cout << "单例模式举例被析构了！" << std::endl;
24 };   //析构函数
25 
26 sigle_class * sigle_class::init(){
27 
28     if (sigle == NULL) {
29        sigle = new sigle_class();
30     }
31     return  sigle;
32 };
33 
34 int  main(int argv ,char args []){
35 
36     sigle_class  *sigle= sigle_class::init();    //定义个sigle_class 实例
37       sigle->show();
38     sigle_class  * mode = sigle_class::init();   //顶一个mod的实例
39       mode->show();
40       if (sigle == mode) {
41           std::cout << "sigle == mode" << std::endl;
42       }
43       else {
44           std::cout << "sigle is not equal mode!" << std::endl;
45       }
46       getchar();
47     return 0;
48 }

当然，我们在日常项目中，解愁到的单例模式，远比这个要复杂得多。这里只是打个比方而已！他会设计到单例模式中的两种模式：赖汉模式，和饱汉模式。

这里因为是对所有的模式，作总结，就不一一例举了！

其实将《泡妞与设计模式》中的那句话改一下，可以这样形容这个模式：

　　假如有一个王二小（不是为鬼子带路的王二小），他超爱玩游戏，所以在很多的游戏中都有自己的账号。这就是说，这些账号只有王二小可以使用（当然，这里我们就不说，王二小将账号给朋友去玩了哈！）。这就是一个单例模式。很多时候，单例模式和静态类有点类似，但是不尽相同。

2. 工厂模式:

工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

举个栗子：

calc.h 头文件

 1 #pragma once
 2  #ifndef _CALC__H__
 3  #define _CALC__H__
 4 #include"Method.h"
 5 
 6 //这部分，用来处理得到的数据
 7 //继承
 8 template<typename Tre , typename in >
 9 class calc : private method<Tre>{
10 
11 public :    
12     //构造函数
13         calc() ;
14         ~calc() {};
15      void show(in ,Tre ,Tre);
16     
17 };
18 
19 //定义一个魔板构造函数
20 template<typename Tre, typename in>
21 calc<Tre, in >::calc() {
22 
23     cout << "is being constructor !" << endl;
24 };
25 
26 //通过封装这个+-*/，并调用这个函数
27 template<typename Tre, typename in>
28 void calc<Tre, in >::show(in type, Tre a, Tre b) {
29 
30     char *p[5] = { "+","-","*","/" };
31     printf("%lf %s %lf = %lf n", a, p[type], b,this->Add(a,b));
32     
33 }
34 
35 #endif

Method.h 头文件

 1 #pragma once
 2 #ifndef _METHOD_H_
 3 #define _METHOD_H_
 4 #include <stdexcept>
 5 #include"Calc.h"
 6 
 7 /*
 8  实现 加 减 乘 除
 9 */
10 template<typename T >
11 class method{
12 public :
13       method() {};
14      ~method() {};
15      T  Add ( T  , T   )    ;
16      T Sub (T   , T  )    ;
17      T Mul (T  , T     );
18      T Div ( T , T  );
19 };
20 
21 
22 template<typename T >
23 T method< T >::Add(T a, T  b) {
24 
25     return a + b;
26 }
27 
28 template<typename T >
29 T  method< T >::Sub(T pre, T nex) {
30 
31     return pre - nex;
32 }
33 
34 template<typename T >
35 T method< T >::Mul(T a, T b) {
36 
37     return a*b;
38 }
39 
40 template<typename T >
41 T method< T >::Div(T a, T b) {
42     if (b == 0) {
43         throw out_of_range("被除数为0,这是违反的！");
44         return  -INT_MAX;
45     }
46     return a / b；
47 }
48 
49 #endif

Main.cpp

 1 /* 设计模式之计算器 比如： 加 减 乘 除 */
 2 #include<iostream>
 3 #include"Calc.h"
 4 #include"Method.h"
 5 #include<stdio.h>
 6 
 7 using namespace std;
 8 
 9 int main(int argv ,char args [] ) {
10 
11     calc<double,int >  mycalc;
12     printf("hello the worlkd !! n");
13     mycalc.show(0,4.0,2);
14     getchar();
15     return 0;
16 }

这种模式其实跟我们说所的继承差不离，但是继承只是一个语言功能，而这种模式是分配调度.....两者存在本质上的不同、就如上面的例子而言，其加减乘除全部是来自另一个calc类，而充当method的父类，method作为核心类，只是作为一个枢纽而已。它的计算功能依附其他的例，这在java就是interface(接口)来完成这些重要的功能。

3 . 工厂方法模式：

定义：

工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

那么，举个栗子：

额，这让我想起了<篮球火>，那就说说篮球的队，我们知道篮球队是有队员组成的，其中队员扮演不同的角色（5个吧），大前锋，中峰，小前锋，得分后卫，和控球后卫。那么，我们可以将篮球队做成一个抽象类，然后各个角色充当具体类。

看代码：（简单的描述一下下）

//Game.h

#pragma once
#ifndef _GAME_H_
#define _GAME_H_
#include<iostream>
#include<string>
using namespace std;

//篮球比赛
class bigGame {

private :

    //取名字
    string str;

public:

    bigGame(string  st): str(st){ };
    virtual ~ bigGame() {};

    //全明星最有价值职位：
     void  famous_Role() {
        cout << "the most valuer of role is " << str << endl;
    };

};


#endif

//    Roler.h

#pragma once
#ifndef _ROLER_H
#define _ROLER_H
#include "Team.h"
#include "Game.h"
class Roler : public Team {
  
public :
    Roler();
    virtual ~ Roler();
    virtual bigGame * PlayShow();
};

#endif

// team.h

#pragma once
#ifndef _TEAM_H_
#define _TEAM_H_
#include "Game.h"
//充当team的扮演角色
class Team {

public :

   Team();
   virtual ~ Team();
   virtual bigGame * PlayShow(void ) =0 ;

};
#endif

以上是头文件，然后是实现类：采用多文件形式，这个看个人的喜好！！

 1 //  Roler.cpp
 2 
 3 #include "Roler.h"
 4 #include "Game.h"
 5 #include<iostream>
 6 //构造函数
 7   Roler::Roler() {
 8 
 9  }
10 
11 //析构函数
12   Roler::~Roler() {
13 
14   }
15 
16   //角色具体化
17   bigGame * Roler::PlayShow() {
18       //std::cout << "小前锋" << std::endl;
19       return  new  bigGame("小前锋");
20   }
21 
22 //   Team.cpp
23 
24 #include "Team.h"
25 Team::Team() {}
26 Team::~Team() {}
27 
28 
29 //  Main.cpp
30 
31 #include"Roler.h"
32 #include"Team.h"
33 #include<iostream>
34 using namespace std;
35 
36 int main(int args , char argv[]) {
37 
38 
39     Roler myrole;
40     bigGame *my = myrole.PlayShow();
41     my->famous_Role();
42     getchar();
43     return 0;
44 }

　　其实，可以看出，工厂方法模式--其实注重的是对于方法函数的继承，当然工厂方法模式也是有简单工厂模式改进而来，所以有工厂模式的模式~~！

-------------------------------------------------------------华丽丽的分割线----------------------------------------------------------------------------

　　　　　　　　　　　　由于是刚接触到设计模式，没有较为深度的理解，就我所理解的，分享一下下，欢迎大侠们指正！