一,概念
策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
二,策略模式的组成
1)抽象策略角色: 策略类,通常由一个接口或者抽象类实现。
2)具体策略角色:包装了相关的算法和行为。
3)环境角色:持有一个策略类的引用,最终给客户端调用。
三,补充C++知识
类对象的构造顺序是这样的:
1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员
2.进入构造函数后在构造函数中执行一般计算
1)类里面的任何成员变量在定义时是不能初始化的。
2)一般的数据成员可以在构造函数中初始化。
3)const数据成员必须在构造函数的初始化列表中初始化。
4)static要在类的定义外面初始化。
5)数组成员是不能在初始化列表里初始化的。
6)不能给数组指定明显的初始化。
这6条一起,说明了一个问题:C++里面是不能定义常量数组的!因为3和5的矛盾。这个事情似乎说不过去啊?没有办法,我只好转而求助于静态数据成员。
到此,我的问题解决。但是我还想趁机复习一下C++类的初始化:
1.初始化列表:CSomeClass::CSomeClass() : x(0), y(1){}
2.类外初始化:int CSomeClass::myVar=3;
3.const常量定义必须初始化,C++类里面使用初始化列表;
4.C++类不能定义常量数组。
在C++类中,必须做如下事情:
1.必须对任何const或引用类型成员以及没有默认构造函数的 类 类型 的任何成员 显示地使用初始化列表进行初始化
2.类成员在定义时是不能被初始化的。
3.类的成员初始化顺序与成员变量在构造函数中的位置选后顺序无关,至于成员变量在类中定义的先后顺序有关。
C++默认继承方式为private
C++ new 生成的对象为指针,所以new 前面的对象要声明为指针类型
四,实例
计算器简单工厂模式的精简实现
#include <iostream> using namespace std; class COperation//基类 { public: int m_nFirst; int m_nSecond; virtual double GetResult() { double dResult=0; return dResult; } }; class AddOperation : public COperation//加法 { public: virtual double GetResult() { return m_nFirst+m_nSecond; } }; class SubOperation : public COperation//减法 { public: virtual double GetResult() { return m_nFirst-m_nSecond; } }; class CCalculatorFactory//工厂类 { public://静态方法属于类本身,不属于哪个对象 static COperation* Create(char cOperator); }; COperation* CCalculatorFactory::Create(char cOperator)//工厂类的实现 { COperation *oper; //在C#中可以用反射来取消判断时用的switch,在C++中用什么呢?RTTI?? switch (cOperator) { case '+': oper=new AddOperation(); break; case '-': oper=new SubOperation(); break; default: oper=new AddOperation(); break; } return oper; } int main() { int a,b; cin>>a>>b; /*静态方法为类所有,可以通过对象来使用,也可以通过类来使用。 但一般提倡通过类名来使用,因为静态方法只要定义了类,不必建立类的实例就可使用*/ COperation * op = CCalculatorFactory::Create('-');//静态方法调用方式 op->m_nFirst=a; op->m_nSecond=b; cout<<op->GetResult()<<endl; return 0; }
将简单工厂模式优化为策略模式后的代码如下:
#include <iostream> using namespace std; //策略基类 class COperation { public: int m_nFirst; int m_nSecond; virtual double GetResult() { double dResult=0; return dResult; } }; //策略具体类-加法类 class AddOperation : public COperation { public: AddOperation(int a,int b) { m_nFirst=a; m_nSecond=b; } virtual double GetResult() { return m_nFirst+m_nSecond; } }; class Context//策略类 { private: COperation* op; public: Context(COperation* temp)//参数为策略基类(传递的时候被初始化为子类) { op=temp; } double GetResult() { return op->GetResult(); } }; //客户端 int main() { int a,b; char c; cin>>a>>b; cout<<"请输入运算符:"; cin>>c; switch(c) { case '+': Context *context=new Context(new AddOperation(a,b)); cout<<context->GetResult()<<endl; break; default: break; } return 0; }
这里将策略(操作符)封装成一个Context类,通过传递操作符子对象来返回相应子对象下操作结果。
菜鸟实现工厂模式和策略模式
客户端只需访问Context类,而不用知道其它任何类信息,实现了低耦合。在上例基础上,修改下面内容
#include <iostream> using namespace std; //策略基类 class COperation { public: int m_nFirst; int m_nSecond; virtual double GetResult() { double dResult=0; return dResult; } }; //策略具体类-加法类 class AddOperation : public COperation { public: AddOperation(int a,int b) { m_nFirst=a; m_nSecond=b; } AddOperation() { m_nFirst=0; m_nSecond=0; } virtual double GetResult() { return m_nFirst+m_nSecond; } }; class Context { private: COperation* op; public: Context(char cType) { switch (cType) { case '+': op=new AddOperation(3,8); break; default: op=new AddOperation(); break; } } double GetResult() { return op->GetResult(); } }; //客户端 int main() { Context *test=new Context('+'); cout<<test->GetResult()<<endl; return 0; }
五,商场促销例子
这里想说的是,abstract 关键字是微软为C#定义的,抽象类关键字。C++中没有抽象类,如果想成为抽象类在类中定义纯虚函数就可以了。只要拥有纯虚函数的类就是抽象类,由于抽象类包含了没有定义的纯虚函数,所以不能定义抽象类的对象。
商场促销的简单工厂实现:
#include <iostream> using namespace std; class CashSuper //现金收费抽象类 { public: virtual double acceptCash(double money)//不能设置为纯虚函数,后面还要生成对象用呢!!!! (不能只定义,而不实现) { } }; class CashNormal : public CashSuper //收费子类,正常收费 { public: double acceptCash(double money) { return money; } }; class CashRebate : public CashSuper //打折收费子类 { private: double moneyRebate;//不允许初始化 public: CashRebate(double moneyRebate) { this->moneyRebate=moneyRebate; } double acceptCash(double money) { return money*moneyRebate; } }; class CashReturn :public CashSuper //返利收费子类(默认继承为私有继承) { private: double moneyCondition ;//返利购买额度 double moneyReturn ;//返利多少 public: CashReturn(double moneyCondition,double moneyReturn) { this->moneyCondition=moneyCondition; this->moneyReturn=moneyReturn; } double acceptCash(double money) { double result = money; if(money >= moneyCondition ) result = money-(money/moneyCondition)*moneyReturn; return result; } }; class CashFactory { public: static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类 { CashSuper *cs; if(type=="CashNormal") cs=new CashNormal(); else if(type == "CashRebate") cs=new CashRebate(0.8); else if(type == "CashReturn") cs=new CashReturn(300,100); return cs; } }; int main(int argc, char** argv) { CashSuper *csuper = CashFactory::creatCashAccept("CashRebate"); double result=csuper->acceptCash(500);//500打八折,应该输出 400 cout<<"CashRebate 500 is:"<<result<<endl; return 0; } 策略模式:定义了算法家族,分别封装起来,让它们之间可以相互替换,算法的变化不会影响使用算法的客户。
主要升级就是,将算法封装到Context中,然后通过传递对象生成相应子类对象,然后得到结果。
#include <iostream> using namespace std; class CashSuper //现金收费抽象类 { public: virtual double acceptCash(double money)//不能设置为纯虚函数,后面还要生成对象用呢!!!! { } }; class CashNormal : public CashSuper //收费子类,正常收费 { public: double acceptCash(double money) { return money; } }; class CashRebate : public CashSuper //打折收费子类 { private: double moneyRebate;//不允许初始化 public: CashRebate(double moneyRebate) { this->moneyRebate=moneyRebate; } double acceptCash(double money) { return money*moneyRebate; } }; class CashReturn :public CashSuper //返利收费子类(默认继承为私有继承) { private: double moneyCondition ;//返利购买额度 double moneyReturn ;//返利多少 public: CashReturn(double moneyCondition,double moneyReturn) { this->moneyCondition=moneyCondition; this->moneyReturn=moneyReturn; } double acceptCash(double money) { double result = money; if(money >= moneyCondition ) result = money-(money/moneyCondition)*moneyReturn; return result; } }; /*class CashFactory { public: static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类 { CashSuper *cs; if(type=="CashNormal") cs=new CashNormal(); else if(type == "CashRebate") cs=new CashRebate(0.8); else if(type == "CashReturn") cs=new CashReturn(300,100); return cs; } };*/ class CashContext { private: CashSuper cs; public: CashContext(CashSuper csuper) { this->cs=csuper; } double GetResult(double money) { return cs.acceptCash(money); } }; int main(int argc, char** argv) { //CashSuper *csuper = CashFactory::creatCashAccept("CashRebate"); //double result=csuper->acceptCash(500);//500打八折,应该输出 400 CashContext *cs; string type="CashRebate"; if(type=="CashNormal") cs=CashContext(new CashNormal()); else if(type == "CashRebate") cs=CashContext(new CashRebate(0.8)); else if(type == "CashReturn") cs=CashContext(new CashReturn(300,100)); cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl; return 0; }
这样仍然存在缺点:就是让客户端来判断生成哪个子类。
改进策略是,让策略模式和工厂模式结合
#include <iostream> using namespace std; class CashSuper //现金收费抽象类 { public: virtual double acceptCash(double money)//不能设置为纯虚函数,后面还要生成对象用呢!!!! { } }; class CashNormal : public CashSuper //收费子类,正常收费 { public: double acceptCash(double money) { return money; } }; class CashRebate : public CashSuper //打折收费子类 { private: double moneyRebate;//不允许初始化 public: CashRebate(double moneyRebate) { this->moneyRebate=moneyRebate; } double acceptCash(double money) { return money*moneyRebate; } }; class CashReturn :public CashSuper //返利收费子类(默认继承为私有继承) { private: double moneyCondition ;//返利购买额度 double moneyReturn ;//返利多少 public: CashReturn(double moneyCondition,double moneyReturn) { this->moneyCondition=moneyCondition; this->moneyReturn=moneyReturn; } double acceptCash(double money) { double result = money; if(money >= moneyCondition ) result = money-(money/moneyCondition)*moneyReturn; return result; } }; /*class CashFactory { public: static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类 { CashSuper *cs; if(type=="CashNormal") cs=new CashNormal(); else if(type == "CashRebate") cs=new CashRebate(0.8); else if(type == "CashReturn") cs=new CashReturn(300,100); return cs; } };*/ class CashContext { private: CashSuper cs; public: CashContext(string type) { if(type=="CashNormal") this->cs=new CashNormal(); else if(type == "CashRebate") this->cs=new CashRebate(0.8); else if(type == "CashReturn") this->cs=new CashReturn(300,100); } double GetResult(double money) { return cs.acceptCash(money); } }; int main(int argc, char** argv) { CashContext *cs=new CashContext("CashRebate"); cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl; return 0; }
这样客户端只需要更改金额和打折手段就可以了。相对简单工厂的提升为:简单工厂需要让客户调用两个类SuperCash和CashFactory。而结合之后仅仅需要调用CashContext就可以了
相对与策略模式的提升为:客户端需要承担的判断更少了,更简洁了