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

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

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

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

　　举个栗子：

#include<iostream>

class sigle_class {

private :

    sigle_class() {};  //将构造函数私有化
    static sigle_class * sigle; 

public:
    ~sigle_class();
    static sigle_class * init();
    void  show() {
        std::cout <<"这是一个单例模式"<<std::endl;
    }
};

//对于静态变量需要在内外进行必要的初始化！
sigle_class * sigle_class::sigle = NULL;

sigle_class::~sigle_class() {

    std::cout << "单例模式举例被析构了！" << std::endl;
};   //析构函数

sigle_class * sigle_class::init(){

    if (sigle == NULL) {
       sigle = new sigle_class();
    }
    return  sigle;
};

int  main(int argv ,char args []){

    sigle_class  *sigle= sigle_class::init();    //定义个sigle_class 实例
      sigle->show();
    sigle_class  * mode = sigle_class::init();   //顶一个mod的实例
      mode->show();
      if (sigle == mode) {
          std::cout << "sigle == mode" << std::endl;
      }
      else {
          std::cout << "sigle is not equal mode!" << std::endl;
      }
      getchar();
    return 0;
}

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

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

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

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

2.     工厂模式:

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

   举个栗子：

     calc.h 头文件

#pragma once
 #ifndef _CALC__H__
 #define _CALC__H__
#include"Method.h"

//这部分，用来处理得到的数据
//继承
template<typename Tre , typename in >
class calc : private method<Tre>{

public :    
    //构造函数
        calc() ;
        ~calc() {};
     void show(in ,Tre ,Tre);
    
};

//定义一个魔板构造函数
template<typename Tre, typename in>
calc<Tre, in >::calc() {

    cout << "is being constructor !" << endl;
};

//通过封装这个+-*/，并调用这个函数
template<typename Tre, typename in>
void calc<Tre, in >::show(in type, Tre a, Tre b) {

    char *p[5] = { "+","-","*","/" };
    printf("%lf %s %lf = %lf 
", a, p[type], b,this->Add(a,b));
    
}

#endif    

    Method.h 头文件

#pragma once
#ifndef _METHOD_H_
#define _METHOD_H_
#include <stdexcept>
#include"Calc.h"

/*
 实现 加 减 乘 除
*/
template<typename T >
class method{
public :
      method() {};
     ~method() {};
     T  Add ( T  , T   )    ;
     T Sub (T   , T  )    ;
     T Mul (T  , T     );
     T Div ( T , T  );
};


template<typename T >
T method< T >::Add(T a, T  b) {

    return a + b;
}

template<typename T >
T  method< T >::Sub(T pre, T nex) {

    return pre - nex;
}

template<typename T >
T method< T >::Mul(T a, T b) {

    return a*b;
}

template<typename T >
T method< T >::Div(T a, T b) {
    if (b == 0) {
        throw out_of_range("被除数为0,这是违反的！");
        return  -INT_MAX;
    }
    return a / b；
}

#endif

    Main.cpp

/* 设计模式之计算器 比如： 加 减 乘 除 */
#include<iostream>
#include"Calc.h"
#include"Method.h"
#include<stdio.h>

using namespace std;

int main(int argv ,char args [] ) {

    calc<double,int >  mycalc;
    printf("hello the worlkd !! 
");
    mycalc.show(0,4.0,2);
    getchar();
    return 0;
}

   这种模式其实跟我们说所的继承差不离，但是继承只是一个语言功能，而这种模式是分配调度.....两者存在本质上的不同、就如上面的例子而言，其加减乘除全部是来自另一个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

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

//  Roler.cpp

#include "Roler.h"
#include "Game.h"
#include<iostream>
//构造函数
  Roler::Roler() {

 }

//析构函数
  Roler::~Roler() {

  }

  //角色具体化
  bigGame * Roler::PlayShow() {
      //std::cout << "小前锋" << std::endl;
      return  new  bigGame("小前锋");
  }

//   Team.cpp

#include "Team.h"
Team::Team() {}
Team::~Team() {}


//  Main.cpp

#include"Roler.h"
#include"Team.h"
#include<iostream>
using namespace std;

int main(int args , char argv[]) {


    Roler myrole;
    bigGame *my = myrole.PlayShow();
    my->famous_Role();
    getchar();
    return 0;
}

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

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

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