设计模式2：策略模式

例子来源于《大话设计模式》第二章。

策略模式的作用：封装算法

在简单工厂模式中，客户端需要认识两个类，分别是工厂类和抽象方法类。而在策略模式里，客户端只需要认识一个类，就是context类。因此，策略模式比简单工厂模式对算法的封装更加彻底。在

在学习一个设计模式的时候，一定要理解它的UML图，这对设计模式的理解很重要。

strategy.h

 

#include<iostream>
using namespace std;
//抽象方法类---现金收费
class CashSuper
{
    public:
    virtual double acceptcash(double money)=0;//纯虚函数
};
//具体方法类-普通方式
class CashNormal:public CashSuper
{
    public:
    double acceptcash(double money)
    {
        return money;
    }
};
//具体方法---打折
class CashRebate:public CashSuper
{
private:
    double discount;
public:
    CashRebate(double discount)//构造函数。构造函数可以有参数，但是不能有返回值，void类型都不行
                               //在初始化的时候，传入具体的策略对象
    {
        this->discount=discount;
    }
    double acceptcash(double money)
    {
        return money*discount;
    }
};
//具体方法--满减
//满减是针对总共的价格来讲的
class CashReturn:public CashSuper
{
    private:
    double moneycondition;
    double moneyreturn;
    public:
    
    CashReturn(double moneycondition,double moneyreturn)//构造函数，这个必须写，可以参考cashcontext.h里对这个类的调用
                                                        //在cashcontext.h里对它的调用有两个参数
                                                        //因为后面要new一个对象，并且给对象赋初值，所以必须写带参数的构造函数来调用
    {
        this->moneycondition=moneycondition;
        this->moneyreturn=moneyreturn;
    }
    double acceptcash(double money)
    {
        double result=money;
        if(money>=moneycondition)
        {
            result=money-money/moneycondition*moneyreturn;
        }
        return result;
    }
};

 

CashContext.h

#include "strategy.h"
//context类
class CashFactory
{
    CashSuper *cas;//子对象
public:
    
    CashFactory(int type):cas(NULL)  
    //构造函数,通过初始化列表初始化数据成员
    //子对象的初始化方式
    //参数不是一个具体的收费策略的对象，而是一个表示收费类型的数字
    //为什么这里写的注释和别的地方不一样？？？
    {
        switch(type)
        {
            case 1:
            cas=new CashNormal();
            break;
            case 2:
            cas=new CashRebate(0.8);//打折方式
            break;
            case 3:
            cas=new CashReturn(200,100);//满减
            break;
            default:;
        }
    }
    ~CashFactory()//析构函数.没有参数，没有返回值，不能重载
                    //作用是释放使用完的指针内存空间
    {
        if(cas!=NULL)
        {
            delete cas;
            cas=NULL;
        }
    }
    double getresult(double money)
    {
        return cas->acceptcash(money);
    }
};

main.cpp

#include"CashContext.h"
#include<iostream>
using namespace std;
int main()
{
    double totalprice=0.0;
    CashFactory *cash=NULL;//策略模式只需要建立context的对象
    cash=new CashFactory(2);//给新建的对象初始化
    totalprice=cash->getresult(300);//使用context的对象访问对应的算法，参考context函数
    cout<<totalprice;
    return 0;
}

构造函数：

有两种：

1.自己写出来，根据自己要建立的对象初始化的方式来写自己需要的构造函数，可以有参数，也可以没参数，但是一旦写了没有参数的系统就不会提供默认的构造函数。

2.不写，系统会提供一个空的构造函数，里面什么都没有。但是这并不代表建立对象的时候不能将它初始化。

按照c++书上的说法，如果有参数，并且想要参数随着自己建立对象的不同而变化，就必须写自己的构造函数。但是也不一定。具体看下面我写的。

在c++中，建立一个对象，就必须调用构造函数。如果没有些构造函数，默认的构造函数不能对类中的成员初始化。但是，没有构造函数，公有的数据成员可以用初始值列表进行初始化。例如：

class Myclass
{
    public:
    int no;
    int year;
};
int main()
{
    Myclass a={25,20};
    cout<<a.no<<endl;
    cout<<a.year<<endl;
    return 0;
}

但是对象的初始化如过写成

Myclass a(25,24);

就不行。

原因是这种初始化只能调用默认的构造函数，但是默认的构造函数没有参数。同理，如果new一个对象并初始化也不可以。