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

#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;

}