c++学习之模型

策略模式

策略模式:定义了算法家族，分别封装起来，让他们之间可以相互替换。
此模式让算法的变化不会影响到使用算法的用户。其实内部的算法就是多态的实现，
让父类指针指向子类对象，就会调用子类里面的函数实现，而不会仅仅指向子类对象。

我们先看着在没有虚函数的情况下怎么实现

#include <iostream>using namespace std;class Strategy{ //执行策略  public:      void Execution(){};};//策略类型1class Strategy1:public Strategy{   public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计1:大肆采用结婚用品\n";  }};class Strategy2:public Strategy{  public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计2:皇城操贼打荆州\n";   }};class Strategy3:public Strategy{  public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计3:向孙小妹求婚!\n";    }};//锦囊妙计 void Choice(Strategy *pStrategy) {   pStrategy->Execution();         }//持锦囊之人int main(int argc,char *argv[]){       //创建父类对象        Strategy  p1;       //创建子类对象        Strategy1 pStrategy1;        Strategy2 pStrategy2;        Strategy3 pStrategy3;        //对象单独调用 //分别调用会调用各自对象里面的值        p1.Execution();        pStrategy1.Execution();        pStrategy2.Execution();        pStrategy3.Execution();        //如果是让父类的指针指向子类对象就会产生调用子类对象的结果。全部调用父类的实现        //放进去的是子类对象，就会产生子类指指针，放进去的是父类对象就会调用父类的函数        Choice(&p1);        Choice(&pStrategy1);        Choice(&pStrategy2);        Choice(&pStrategy3);return 0;       }

可以看到这个时候让父类指针指向父类或者子类都无法实现多态，因为这个时候父类里面没有多态产生条件之一:虚函数，所以我们要单独进行调用比较麻烦。而且此时我们破坏了类的封装特性，所以我们用虚函数实现多态。

用虚函数实现多态

#include <iostream>using namespace std;/*  策略模式;定义了算法家族，分别封装起来，让他们之间可以相互替换。  此模式让算法的变化不会影响到使用算法的用户*/class Strategy{ //执行策略  public:     virtual void Execution(){};};//策略类型1class Strategy1:public Strategy{   public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计1:大肆采用结婚用品\n";  }};class Strategy2:public Strategy{  public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计2:皇城操贼打荆州\n";   }};class Strategy3:public Strategy{  public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计3:向孙小妹求婚!\n";    }}; void Choice(Strategy *pStrategy) {   pStrategy->Execution();         }//持锦囊之人int main(int argc,char *argv[]){        Strategy  p1;        Strategy1 pStrategy1;        Strategy2 pStrategy2;        Strategy3 pStrategy3;                //放进去的是子类对象，就会产生子类指指针，放进去的是父类对象就会调用父类的函数        Choice(&p1);        Choice(&pStrategy1);        Choice(&pStrategy2);        Choice(&pStrategy3);        return 0;       }

上面这个例子我们虽然实现了多态，但是我们把choice()函数单独拿出来，这样破坏了类的封装结构。

所以我们把程序进一步改良得到最终的程序，添加进了纯虚函数

#include <iostream>using namespace std;class Strategy{ //执行策略  public:    virtual void Execution()=0;};//策略类型1class Strategy1:public Strategy{   public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计1:大肆采用结婚用品\n";     }     };class Strategy2:public Strategy{  public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计2:皇城操贼打荆州\n";   }};class Strategy3:public Strategy{  public:  //对虚函数进行重写  void Execution()  {    cout<<"妙计3:向孙小妹求婚!\n";    }};//锦囊妙计class Bag{ private: //定义一个指针    Strategy *pStrategy; public: //构造成员函数 Bag(Strategy *p):pStrategy(p) {}  //让父类指针指向函数里面的函数 //选择锦囊妙计并执行 void Choice() {   pStrategy->Execution();         }};//持锦囊之人int main(int argc,char *argv[]){        //创建父类指针,指向子类对象        Strategy *pStrategy1=new Strategy1;        Strategy *pStrategy2=new Strategy2;        Strategy *pStrategy3=new Strategy3;        //这是一个多态的过程        //通过基类的指针调用        //调用有参构造函数，构造Bag类型的对象指针        Bag *pBag1=new Bag(pStrategy1);//调用有参构造函数        Bag *pBag2=new Bag(pStrategy2);//将父类指针指向子类对象或者父类对象        Bag *pBag3=new Bag(pStrategy3);//以实现多态        //Bag类的对象调用其中对象的函数，对象中的对象指针已经赋值了        pBag1->Choice();        pBag2->Choice();        pBag3->Choice();        return 0;}