职责链模式和工厂模式混合求解一个简单的解密问题

#include "oj.h"
#include <stdlib.h>
#include <iostream>
#include <string>
#include <stdlib.h>
#include <typeinfo>
#include <vector>
#include <memory>
using namespace std;

/* 功能：取得解密串
 * 输入：intputstr :加密串
 * 输出：pOutputstr：解密串
 * 返回：解密成功返回0，否则返回-1
 */

/*
详细描述：

输入一篇加密后的字符串，输出解密后的字符串。

规则：

1.获得一段文字后，求出它的长度(包括空格)len。

2.进入加密运算的第1步:把所有下标是1倍数的字符做顺时针旋转。

3.进入加密运算的第2步:把所有下标是2倍数的字符做逆时针旋转。

4.进入加密运算的第3步:把所有下标是3倍数的字符做顺时针旋转。

5.按上面的规则，第奇数步按顺时针旋转，偶数步按逆时针旋转，一直到第len步为止。

 

例子：

比如原文是:abcde

1.获得长度len = 5

2.1的倍数有1、2、3、4、5，所以把这5个字符按顺时针旋转，得到eabcd。

3.2的倍数有2、4，所以把这2个字符按逆时针旋转，得到ecbad。

4.3的倍数有3，所以把这1个字符按顺时针旋转，得到ecbad。

5.4的倍数有4，所以把这1个字符按逆时针旋转，得到ecbad。

6.5的倍数有5，所以把这1个字符按顺时针旋转，得到ecbad。

最后的结果是ecbad。

*/
struct StManipulateStr
{
 static string revert(string strInput,unsigned int factor)
 {  
  unsigned int len=(strInput.size());
  unsigned int msize=len/factor; // 5/2=2,5/3=1,5/4=1,5/5=1
  if(msize<=1) return strInput;
  try
  {
  char* temp1=new char[len+1];
        char* temp2=new char[len+1];
  memcpy(temp1,strInput.c_str(),size_t(len));
  memcpy(temp2,strInput.c_str(),size_t(len));//输出延续输入
  temp1[len]='\0';
        temp2[len]='\0';

  for(int i=1;i<=msize;i++)
  {
   temp2[i*factor-1]=temp1[(msize-i+1)*factor-1];
  }
  std::cout<<endl<<"in StManipulateStr:"<<temp2<<endl;
  return string(temp2);
  }catch(...){}
  
 }
 static string clockwise(string strInput,unsigned int factor,bool flag)
 {  
  unsigned int len=(strInput.size());
  unsigned int msize=len/factor; // 5/2=2,5/3=1,5/4=1,5/5=1
  if(msize<=1) return strInput;

  std::cout<<endl<<"in StManipulateStr:"<<strInput<<endl;

  try
  {
  char* temp=new char[len+1];
  memcpy(temp,strInput.c_str(),size_t(len));
        temp[len]='\0';
  if(flag)//顺时针
  {
   char sentinel=temp[msize*factor-1];
   for(int i=msize;i>1;i--)
   {
    temp[i*factor-1]=temp[(i-1)*factor-1];
   }
   temp[factor-1]=sentinel;
  }
  else
  {
   char sentinel=temp[factor-1];
   for(int i=1;i<msize;i++)
   {
    temp[i*factor-1]=temp[(i+1)*factor-1];
   }
   temp[msize*factor-1]=sentinel;
  }
  std::cout<<endl<<"in StManipulateStr:"<<temp<<endl;
  return string(temp);
  }catch(...){}
  
 }
};
class AbsRequest
{
 virtual void convertResult(char*)=0;
};// 职责链模式的请求对象
class Request:public AbsRequest
{
public:
 Request(char* str)
 {
  _str=string(str);
  _resultStr=string(str);
  
 }
 int getLen(){return static_cast<int>(_str.size());}
 void setResult(string instr)
 {
  _resultStr=instr;
 }
 void convertResult(char* pbuf){strcpy(pbuf,_resultStr.c_str());}
 string getStr(){return _str;};
 string getResult(){return _resultStr;};
private:
 string _str;
 string _resultStr;
};
class AbsHandler
{
public:
 AbsHandler()
 {
  _nextHandler=NULL;
  cout<<endl<<"AbsHandler constructor"<<endl;
 }
 virtual ~AbsHandler(){}// 虚析构函数
 virtual bool handle(AbsRequest& mareq){std::cout<<"name of the para is:"<<typeid(mareq).name()<<endl; return true;};
 virtual AbsHandler* getNext(){return _nextHandler;};
 virtual void setNext(AbsHandler* mreq){_nextHandler=mreq;};
protected:
 AbsHandler* _nextHandler;
};
class ConcreteHandler:public AbsHandler
{
public:
 ConcreteHandler(bool flag,unsigned int fac):_flag(flag),_factor(fac){cout<<"ConcreteHandler constructor"<<endl;}
 ~ConcreteHandler(){cout<<"ConcreteHandler destructor"<<endl;}
 virtual bool handle(AbsRequest& mareq)
 {
  
  try
  {
   std::cout<<"in function handle:name of the para is:"<<typeid(mareq).name()<<endl;
   Request& mreq=dynamic_cast<Request&>(mareq); 
   mreq.setResult(StManipulateStr::clockwise(mreq.getResult(),_factor,_flag));//本节处理
   if(NULL==_nextHandler)
   {
    std::cout<<"next handler null"<<endl;
    return false;//什么也不做
   }
      return _nextHandler->handle(mreq); //继续下一步的处理
  }
  catch(bad_cast){}
  
 };
 
private:
 bool _flag;
 unsigned int _factor;
};
class AbsFactory
{
public:
 virtual ~AbsFactory(){}
 virtual AbsHandler* getProduct(bool,unsigned int fac )=0;
};
class HandlerFactory: public AbsFactory
{
public:
 HandlerFactory(){cout<<endl<<"HandlerFactory constructor "<<endl;}
 ~HandlerFactory(){cout<<"HandlerFactory destructor "<<endl;}
 AbsHandler* getProduct(bool flag,unsigned int fac)
 {
  return new ConcreteHandler(flag,fac);  
 }//getProduct
};
extern unsigned int GetDecrypt(char* intputstr, char** pOutputstr)
{
 if(NULL==intputstr||NULL==pOutputstr) return -1;
 try
 {
  
  auto_ptr<HandlerFactory> pmfac(new HandlerFactory);
  int len=string(intputstr).length();
  
  vector<AbsHandler*> hvec;

  for(int i=1;i<=len;i++)
  { 
   AbsHandler* han=pmfac->getProduct((1==(i%2)),i); 
   hvec.push_back(han);
  }
  vector<AbsHandler*>::iterator iter=hvec.begin();
        for(int i=0;i<len-1;i++)
  { 
   (*iter)->setNext(hvec.at(i+1));
   iter++;
  }
  Request mreq(intputstr);// 新建一个需求
  hvec.at(0)->handle(mreq);//处理需求
  
  
  char* buf=(char*)malloc(mreq.getLen()+1);//开辟内存
  mreq.convertResult(buf);//复制结果
  *pOutputstr=buf;//输出结果
  
 }catch(...){}
 return 0;
}