C++深入浅出设计模式

　　看大话设计模式中大牛对小菜的精辟点评，也写了一个计算器程序，并跟着点评一路改良，还是不过瘾，应用了类模板和异常捕捉机制重写了程序。
　　
　　本文不能算干货，恰当的比方是饭前甜点，吃一口有点味、有点意思，总归太小不管饱。
　　
　　 #include<stdlib.h>
　　
　　#include<stdio.h>
　　
　　#include<iostream>
　　
　　#include<Windows.h>
　　
　　#include<exception>
　　
　　using namespace std;
　　
　　template <typename T>
　　
　　class myOperation
　　
　　{
　　
　　public:
　　
　　virtual void SetNumberA(const T& val){NumberA = val;}
　　
　　virtual void SetNumberB(const T& val){NumberB = val;}
　　
　　virtual T GetNumberA() {return NumberA;}
　　
　　virtual T GetNumberB() {return NumberB;}
　　
　　myOperation(const T& valA, const T& valB) {NumberA = valA; NumberB = valB;}
　　
　　myOperation(){NumberA = 0; NumberB = 0;}
　　
　　myOperation(const myOperation& other){NumberA = other.NumverA; NumverB = other.NumberB;}
　　
　　~myOperation() {}
　　
　　virtual T Operation() = 0;
　　
　　private:
　　
　　T NumberA;
　　
　　T NumberB;
　　
　　};
　　
　　template <typename T>
　　
　　class myPlusOperation : public myOperation<T>
　　
　　{
　　
　　public:
　　
　　T Operation();
　　
　　myPlusOperation(){}
　　
　　myPlusOperation(const T& valA, const T& valB):myOperation(valA, valB){}
　　
　　myPlusOperation(const myPlusOperation& other){myOperation(other);}
　　
　　~myPlusOperation(){}
　　
　　};
　　
　　template <typename T>
　　
　　class myMinusOperation : public myOperation<T>
　　
　　{
　　
　　public:
　　
　　T Operation();
　　
　　myMinusOperation() {}
　　
　　myMinusOperation(const T& valA, const T& valB):myOperation(valA, valB){}
　　
　　myMinusOperation(const myMinusOperation& other){myOperation(other);}
　　
　　~myMinusOperation(){}
　　
　　};
　　
　　template <typename T>
　　
　　class myMultipleOperation : public myOperation<T>
　　
　　{
　　
　　public:
　　
　　T Operation();
　　
　　myMultipleOperation() {}
　　
　　myMultipleOperation(const T& valA, const T& valB):myOperation(valA, valB){}
　　
　　myMultipleOperation(const myMultipleOperation& other){myOperation(other);}
　　
　　~myMultipleOperation(){}
　　
　　};
　　
　　template <typename T>
　　
　　class myDivideOperation : public myOperation<T>
　　
　　{
　　
　　public:
　　
　　T Operation();
　　
　　myDivideOperation() {}
　　
　　myDivideOperation(const T& valA, const T& valB):myOperation(valA, valB){}
　　
　　myDivideOperation(const myDivideOperation& other){myOperation(other);}
　　
　　~myDivideOperation(){}
　　
　　};
　　
　　template <typename T>
　　
　　T myPlusOperation<T>::Operation()
　　
　　{
　　
　　return GetNumberA()+GetNumberB();
　　
　　};
　　
　　template <typename T>
　　
　　T myMinusOperation<T>::Operation()
　　
　　{
　　
　　return GetNumberA()-GetNumberB();
　　
　　};
　　
　　template <typename T>
　　
　　T myMultipleOperation<T>::Operation()
　　
　　{
　　
　　return GetNumberA()*GetNumberB();
　　
　　};
　　
　　template <typename T>
　　
　　T myDivideOperation<T>::Operation()
　　
　　{
　　
　　if(GetNumberB() == 0)
　　
　　throw exception("除数不能为0"); //抛出对象，catch引用可以捕捉到
　　
　　return GetNumberA()/GetNumberB();
　　
　　};
　　
　　template <typename T>
　　
　　class myOperationFactory
　　
　　{
　　
　　public:
　　
　　static myOperation<T>* CreatemyOperation(char operate); //工厂只提供静态方法获取类实例。
　　
　　};
　　
　　template <typename T>
　　
　　myOperation<T>* myOperationFactory<T>::CreatemyOperation(char operate)
　　
　　{
　　
　　myOperation<T>* oper = NULL; //返回的指针具有实例化类型，指定<T>
　　
　　switch (operate)
　　
　　{
　　
　　case ‘+‘:
　　
　　oper = new myPlusOperation<T>; //new的对象需要指定实例化类型<T>
　　
　　break;
　　
　　case ‘-‘:
　　
　　oper = new myMinusOperation<T>;
　　
　　break;
　　
　　case ‘*‘:
　　
　　oper = new myMultipleOperation<T>;
　　
　　break;
　　
　　case ‘/‘:
　　
　　oper = new myDivideOperation<T>;
　　
　　break;
　　
　　default:
　　
　　throw new exception("Operation isn‘t correct"); //new出来的异常，catch对应的指针可以捕捉到
　　
　　break;
　　
　　}
　　
　　return oper;
　　
　　};
　　
　　void foo44()
　　
　　{
　　
　　try{
　　
　　while(1)
　　
　　{
　　
　　int NumberA = 0, NumberB = 0, Result = 0;
　　
　　char Oper = ‘\0‘;
　　
　　char Enter = ‘\0‘;
　　
　　printf("please input NumberA\n");
　　
　　scanf("%d", &NumberA);
　　
　　printf("please input NumberB\n");
　　
　　scanf("%d", &NumberB);
　　
　　printf("please input operator\n");
　　
　　scanf("%c%c",&Enter, &Oper); //scanf从当前输入流获取下一个匹配的输入，回车换行空格均被视作有效字符
　　
　　myOperation<int>* Operation = myOperationFactory<int>::CreatemyOperation(Oper);
　　
　　Operation->SetNumberA(NumberA);
　　
　　Operation->SetNumberB(NumberB);
　　
　　Result = Operation->Operation();
　　
　　printf("Result is %d\n", Result);
　　
　　delete Operation;
　　
　　}
　　
　　/*myPlusOperation<int> Operation(1, 10);
　　
　　int iResult = Operation.Operation();
　　
　　printf("iResult is %d\n", iResult);*/
　　
　　}
　　
　　//异常捕获之后，try语句块的代码被跳过，程序继续处理以后的代码
　　
　　catch (exception* ex)
　　
　　{
　　
　　cout << ex->what() << endl;
　　
　　}
　　
　　catch (exception& ex)
　　
　　{
　　
　　cout << ex.what() << endl;
　　
　　}
　　
　　catch (...)
　　
　　{
　　
　　cout << "catch an unexpected exception" << endl;
　　
　　}
　　
　　}
　　
　　int main()
　　
　　{
　　
　　foo44();
　　
　　system("PAUSE");
　　
　　}
　　
　　模板直接支持通用型程序设计，即采用类型作为参数的程序设计，使人在定义类和函数时以类型作为参数，模板的一个广泛应用例子即标准库，主要的标准库被抽象成模板：string、ostream、complex、list、vector等。
　　
　　例子中演示了简单的类模板应用，稍微要注意的是类声明外部或者引用其他模板类时别忘了实例化参数。
　　
　　C++的异常捕捉机制基本思想就是：
　　
　　一个函数发现了自己无法处理的错误时抛出一个异常，希望它的直接或间接调用者能处理这个问题，希望处理这类问题的函数可以表明它将要捕捉这个异常。
　　
　　C++的异常捕捉机制将异常视为无法再局部执行有意义的动作时，就将控制权返回给调用者。
　　
　　C++的异常捕捉机制相比传统的错误处理，有许多明显的优越性：
　　
　　在传统技术不充分、不优美时的替代方法，能明确的将错误处理代码从正常代码中分离，是一种更规范的错误处理风格。
　　
　　更友好的错误处理方式，异常默认处理方式为跳过错误代码继续处理，而传统的错误处理默认为终止程序，在一些不允许程序垮台的系统上更有用。
　　
　　异常可以理解成程序不能完成某些工作了，我们可以继续尝试完成其他的工作。
　　
　　简单工厂模式
　　
　　简单工厂能较好的支持同一个基类派生出数个派生类的场景，比如本文的加减乘除，基类提供操作数和操作接口，不同职责的派生类重写操作函数，把差异化的功能实现交给派生类完成，这种设计方式便于添加和修改功能，每一个功能的修改只用修改一个类，新增功能也只用新增一个类和类工厂中添加分支，对用户而言则隔离了差异内容的实例化，用户使用时只需要询问一下“嗨，我要做加法操作，你给我返回一个能操作加法的对象指针”。
　　
　　上面一段描述了简单工厂的三大要素：
　　
　　工厂角色，被外界调用并创建产品对象，通常提供静态方法获取产品对象。
　　
　　抽象产品角色，所有具体产品的父类，包含所有实例共有的公共接口。
　　
　　具体产品角色，一般有多个，工厂创建的具体目标，详细工作的执行者。