2021-03-24

标题 1. 简单的工厂模式

思想：用一个工厂来跟据输入的条件产生不同的类，然后根据不同的类的Virtual 函数得到不同的结果
优点：使用不同情况创建不同的类
缺点：客户端必须要知道工厂类和基类 耦合性差

#include <iostream>
using namespace std;

///工厂类和基类为关联关系

//运算类
class  Operationclass 
{
public:
    int m_first;
    int m_nsecond;
public:
    virtual double GetResult()=0;  
};

//加法
class Addclass :public Operationclass
{
    public:
        double GetResult()
        {
               return  m_first+m_nsecond;
        }   
};
//减法
class SubtractClass :public Operationclass
{
    public:
        double GetResult()
        {
               return  m_first-m_nsecond;
        }   
};

//乘法
class MultiplicationClass :public Operationclass
{
    public:
        double GetResult()
        {
               return  m_first*m_nsecond;
        }   
};

//工厂类
class Plantclass
{
    public:
        static Operationclass *Create(char charOperat);  
};
Operationclass *Plantclass::Create(char charOperat)
{   
    Operationclass *Oper=NULL;
    switch (charOperat)
    {
    case '+':
        Oper=new Addclass();
        break;
     case '-':
        Oper=new SubtractClass();
        break; 
    case '*':
        Oper=new MultiplicationClass();
        break;
    default:
        break;
    }
    return Oper;
}

//客户端
int main()
{
        int a=1,b=2;
        Operationclass * P=Plantclass::Create('+');
        P->m_first=a;
        P->m_nsecond=b;
        Operationclass * P1=Plantclass::Create('-');
        P1->m_first=a;
        P1->m_nsecond=b;
        Operationclass * P2=Plantclass::Create('*');
        P2->m_first=a;
        P2->m_nsecond=b;
        
        std::cout<<P->GetResult()<<std::endl;
        std::cout<<P1->GetResult()<<std::endl;
        std::cout<<P2->GetResult()<<std::endl;
    return 0;
}

标题 2，策略模式

定义算法，分别封装起来，让他们之间可以互相替换，让算法变换，不会影响到用户
优点：适合类中的成员一方法为主，算法经常变动，简化了单元测试（因为每一个算法都有自己的类。可一通过自己的接口单独测试）
策略模式和简单工厂模式基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应该使用策略模式
缺点：客户端要做出判断

#include  <iostream>
using namespace std;

//运算类
class  Operation
{
    public:
        int once;
        int twin;
        virtual double setValue()
        {
             double dResult=0;
             return dResult; 
        }
};
//策略类
class Factoryclass
{
    public:
       Operation *Op;
        Factoryclass(Operation *Opx)
       {
           this->Op=Opx;
       }
         int  GetOpera()
         {
             return this->Op->setValue();
         }
};
//加法
class Addclass :public Operation
{
public:
     Addclass(int a,int b )
    {
            once=a;
            twin=b;
    }
     double setValue()
     {
         return once+twin;
     }
};
//减法
  
 class subtraction :public Operation
{
public:
     subtraction(int a,int b )
    {
            once=a;
            twin=b;
    }
     double setValue()
     {
         return once-twin;
     }
};

//客户端


int  main(int argc,char ** argv)
{
    int a=1,b=2;
    char ch='+';
    switch (ch)
    {
         case '-':
        
            Factoryclass *F1=new Factoryclass(new subtraction(a,b));
            std::cout<<F1->GetOpera()<<std::endl;
                    break;

    }
	switch (ch)
    {
         case '+':
        
            Factoryclass *F1=new Factoryclass(new Addclass(a,b));
            std::cout<<F1->GetOpera()<<std::endl;
                    break;

    }
    system("pause");
    return 0;
}