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 ;
 }

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

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

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

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

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[] = { "+","-","*","/" };
     printf("%lf %s %lf = %lf \n", 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 == ) {
         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 !! \n");
     mycalc.show(,4.0,);
     getchar();
     return ;
 }

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

};
#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 ;
 }

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

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

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