读书 大话设计模式 第一章 简单工厂模式 C++实现 已完

简单工厂模式
1.1  面试受挫
#include  < iostream >

using   namespace  std;

int  main( void )
{
    cout  <<   " 请输入数字 "   <<  endl;
     int  A  =   0 ;
    cin  >>  A;

    cout  <<   " 请输入运算符号(+、-、*、/) "   <<  endl;
     char  B  =   ' + ' ;
    cin  >>  B;
    
    cout  <<   " 请输入数字 "   <<  endl;
     int  C  =   0 ;
    cin  >>  C;

     int  D  =   0 ;

     if  ( B  ==   ' + '  )
        D  =  A  +  C;
     if  ( B  ==   ' - '  )
        D  =  A  -  C;
     if  ( B  ==   ' * '  )
        D  =  A  *  C;
     if  ( B  ==   ' / '  )
        D  =  A  /  C;

    cout  <<   " 结果是 "   <<  D  <<  endl;
     return   0 ;
}

1.2  初学者的毛病
( 1 ) A,B,C,D的变量命名不规范
( 2 ) 判断分支，意味着每个条件都要判断，计算机额外做了三次判断操作
( 3 ) 没有判断除0的条件
( 4 ) 没有考虑到用户输入出错的问题

1.3  规范代码
#include  < iostream >

using   namespace  std;

//  exception constant
#define  DIVID_ZERO_ERROR 0

//  function return constant
#define  OK 0
#define  ERROR -1


// from input stream read a integer
int  ReadInt (  char   * tipMessage  =   " Input Error,you must enter an integer,please again: " )
{
     int  readResult  =   0 ;
    cin  >>  readResult;
     while  ( cin.fail() )
    {
        cout  <<  tipMessage  <<  endl;  // show the user a tip message

        cin.clear();  // reset the fail flag to zero
        cin.sync();  // clear the data of the input stream

        cin  >>  readResult;
    }
     return  readResult;
}

int  main( void )
{
     try
    {
        cout  <<   " Please enter an integer: "   <<  endl;
         int  numberA  =  ReadInt ();
        
        cout  <<   " Please enter an operator(+、-、*、/) "   <<  endl;
         char  arithOperator  =   ' + ' ;
        cin  >>  arithOperator;
        
        cout  <<   " Please enter an integer: "   <<  endl;
         int  numberB  =  ReadInt ();
        
         int  result  =   0 ;
        
         switch  ( arithOperator )
        {
         case   ' + ' :
            result  =  numberA  +  numberB;
             break ;

         case   ' - ' :
            result  =  numberA  -  numberB;
             break ;

         case   ' * ' :
            result  =  numberA  *  numberB;
             break ;

         case   ' / ' :
             if  ( numberB  ==   0  )
            {
                 throw  (DIVID_ZERO_ERROR); 
            }
             else
            {
                result  =  numberA  /  numberB;
            }
             break ;

         default :
             break ;
        }
        
         // out put the result
        cout  <<   " The result is  "   <<  result  <<  endl;
    }
     catch  (  int  errorId)
    {
         switch  (errorId)
        {
             case  DIVID_ZERO_ERROR:
                cout  <<   " Dividing a zero is an error! "   <<  endl;
                 break ;

             default :
                cout  <<   " unknown error id! " ;
        }
         return  ERROR;
    }
     return  OK;
}

1.4  面向对象编程
( 1 )可维护
( 2 )可复用
( 3 )可扩展
( 4 )灵活性好

1.6
通过封装、继承、多态把程序的耦合度降低，用设计模式使得程序更加的灵活，容易修改，并且易于复用。
1.7
小菜: 复制还是复用，这是个问题。
大鸟: 问题你个头,当然是复用啦！
1.8
业务逻辑应该与界面逻辑分开，让它们之间的耦合度降低。
分开才容易维护或者扩展。
#include  < iostream >

using   namespace  std;

#define  DIVIED_ZERO_ERROR 0
#define  NO_DEFINED_OPERATOR 1

#define  OK 0
#define  ERROR -1

class  ArithOperation
{
public :
     static   double  GetResult ( double  numberA,  double  numberB,  char  arithOperator)
    {
         double  result  =   0 ;
         switch  ( arithOperator)
        {
         case   ' + ' :
            result  =  numberA  +  numberB;
             break ;
            
         case   ' - ' :
            result  =  numberA  -  numberB;
             break ;
            
         case   ' * ' :
            result  =  numberA  *  numberB;
             break ;
            
         case   ' / ' :
             if  (numberB  ==   0 )
                 throw  (DIVIED_ZERO_ERROR);
            result  =  numberA  /  numberB;
             break ;
         default :
             throw  ( NO_DEFINED_OPERATOR );
             break ;
        }
        
         return  result;
    }
};


double  ReadDouble (  char   *  tipMessage  =   " Input Error!Please enter an double number again: " )
{
     double  result  =   0.0 ;
    cin  >>  result;
     while  (cin.fail())
    {
        cout  <<  tipMessage  <<  endl;
        
        cin.clear();
        cin.sync();
        
        cin  >>  result;
    }
    
     return  result;
}

int  main ( void )
{
     try
    {
        cout  <<   " Please Enter an dobule number: "   <<  endl;
         double  numberA  =  ReadDouble ();
        
        cout  <<   " Please Enter an arithmetic operator: "   <<  endl;
         char  arithOperator;
        cin  >>  arithOperator;
        
        cout  <<   " Please Enter an double number: "   <<  endl;
         double  numberB  =  ReadDouble ();
        
         double  result  =   0 ;
        result  =  ArithOperation::GetResult ( numberA, numberB, arithOperator );
        
        cout  <<   " The result is "   <<  result  <<  endl;
    }
     catch  (  int  errorId )
    {
         switch  (errorId)
        {
         case  DIVIED_ZERO_ERROR:
            cout  <<   " Dividing zero is error. "   <<  endl;
             break ;

         case  NO_DEFINED_OPERATOR:
            cout  <<   " The opeartor is not defined. "   <<  endl;
             break ;
            
         default :
            cout  <<   " unknow error! "   <<  endl;
             break ;
        }
         return  ERROR;
    }
     return  OK;
}

1.9  紧耦合和松耦合
#include  < iostream >

using   namespace  std;

#define  DIVIED_ZERO_ERROR 0
#define  OPERATION_TYPE_ERROR 1

#define  OK 0
#define  ERROR 1

class  arithOperator
{
protected :
     double  numberA;
     double  numberB;
public :
    arithOperator()
    {
        numberA  =   0 ;
        numberB  =   0 ;
    }

     void  SetNumberA ( double  number)
    {
        numberA  =  number;
    }
     double  GetNumberA ()
    {
         return  numberA;
    }
     void  SetNumberB ( double  number)
    {
        numberB  =  number;
    }
     double  GetNumberB ()
    {
         return  numberB;
    }

     virtual   double  GetResult ()
    {
         double  result  =   0 ;
         return  result;
    }
};

class  OpeartionAdd :  public  arithOperator
{
     virtual   double  GetResult ()
    {
         double  result  =   0 ;
        result  =  numberA  +  numberB;
         return  result;
    }
};

class  OperationSub :  public  arithOperator
{
     virtual   double  GetResult ()
    {
         double  result  =   0 ;
        result  =  numberA  -  numberB;
         return  result;
    }
};

class  OperationMul :  public  arithOperator
{
     virtual   double  GetResult ()
    {
         double  result  =   0 ;
        result  =  numberA  *  numberB;
         return  result;
    }
};

class  OperationDiv :  public  arithOperator
{
     virtual   double  GetResult ()
    {
         if  (numberB  ==   0 )
        {
             throw  (DIVIED_ZERO_ERROR);
        }

         double  result  =   0 ;
        result  =  numberA  /  numberB;

         return  result;
    }
};


double  ReadDouble (  char   *  tipMessage  =   " Input error!Please enter an double number again:\n " )
{
     double  result  =   0 ;

    cin  >>  result;
     while  (cin.fail())
    {
        cout  <<  tipMessage  <<  endl;
        cin.clear();
        cin.sync();
        cin  >>  result;
    }
     return  result;
}

class  OperationFactory
{
public :
     static  arithOperator *  createOperator(  char  operType)
    {
        arithOperator  * operPointer  =  NULL;
         switch  (operType)
        {
         case   ' + ' :
            operPointer  =   new  OpeartionAdd();
             break ;

         case   ' - ' :
            operPointer  =   new  OperationSub();
             break ;

         case   ' * ' :
            operPointer  =   new  OperationMul();
             break ;

         case   ' / ' :
            operPointer  =   new  OperationDiv();
             break ;

         default :
             throw  OPERATION_TYPE_ERROR;
             break ;
        }
         return  operPointer;
    }
};

int  main ( void )
{
     try
    {
    
        cout  <<   " Please enter an double number: "   <<  endl;
         double  numberA;
        numberA  =  ReadDouble();
        
        cout  <<   " Please enter an operator: "   <<  endl;
         char  userOperator;
        cin  >>  userOperator;
        
        cout  <<   " Please enter an double number: "   <<  endl;
         double  numberB;
        numberB  =  ReadDouble();

        arithOperator  * operPointer;
        operPointer  =  OperationFactory::createOperator (userOperator);
        operPointer -> SetNumberA(numberA);
        operPointer -> SetNumberB(numberB);
        
         double  result  =   0 ;
        result  =  operPointer -> GetResult();

        cout  <<   " The result is  "   <<  result  <<  endl;
        
        delete operPointer;

         return  OK;

    }
     catch  (  int  errorId )
    {
         switch  (errorId)
        {
         case  DIVIED_ZERO_ERROR:
            cout  <<   " Diving zero is an error! "   <<  endl;
             break ;

         case  OPERATION_TYPE_ERROR:
            cout  <<   " Operator type is error! "   <<  endl;
             break ;

         default :
            cout  <<   " Unknown error! "   <<  endl;
             break ;
        }

         return  ERROR;
    }
    
}

总结：工厂只负责生产由用户指定的产品，这样的设计好处是每种产品独立，如果程序需要修改其中某一个产品，那么他不需要改动其它产品的代码，也不需要改动工厂的代码，当然，界面代码也不需要改动，改动的只是产品的内在。
如果要添加一种新的产品，则需添加新的类并修改工厂类。
注意：产品必须是同一种功能，也就是同样的方法名称。

C ++ 步骤:
1 .定义抽象类，并定义一个虚拟的方法
2 .从该抽象类派生出子类，实现同一个方法
3 .定义工厂，提供函数，根据用户的输入，生产出不同的对象，注意，这里用的是NEW,所以用
4 .利用这个对象进行操作
5 .删除对象