liuhuiyan_2014的专栏

#include <iostream>#include <windows.h>#include <mutex>using namespace std;std::mutex _sMutex;template<typename Type>class Singleton{public: static Type* GetSigleton() { if (sin

//main.h#pragma onceclass Mediator;class School{public: virtual void action()=0; virtual void Setname(const char *buff)=0;protected: Mediator *mt; char namebuff[10];};class Studentone : p

//Memento记忆模式。#include <iostream>#include <string.h>using namespace std;class Memento;class Originator{public: Originator(char *s = "") { _str = new char[100]; strcpy(_st

#include <iostream>using namespace std;//Bridge桥接模式。class Base{public: virtual void Printf()=0;};class Son1 :public Base{public: void Printf() { cout << "Son1::Printf()" <<

#include <iostream>#include <string.h>#include <vector>using namespace std;//观察者模式。//定义了一对多的关系，让多个观察对象同时监听一个主题对象，//当主题对象发生变化时，多个对象作出相应的响应。class School{public: School(char *s) {

#include <iostream>#include <windows.h>#include <mutex>std::mutex gmutex;using namespace std;template<typename Type>class Singleton{public: static Type* GetSingleton() { if (s

#include <iostream>using namespace std;class Contex;//即使此处声明了，如果类中调用的有Contex函数，//那么编译器也会找不到定义的地方，所有这里我将//所有的类的实现都延迟在外面，这样对于每一个类而言，//其他的类都是可见的，最大的好处就是类之间的相互调用//不会产生什么未定义类型的错误警告。class Base{publi

#include <iostream>using namespace std;class Base{public: void DoWhat() { this->Printf1(); this->Printf2(); } virtual void Printf1() = 0; virtual void Printf2() =

#include <iostream>using namespace std;//template模式。class Base{public: void DealWhat() { this->Printf1(); this->Printf2(); }protected: virtual void Printf1() = 0;

#include<iostream>using namespace std;//从一个对象再创建另一个可定制的对象，无需知道任何的细节，并能提高创建的性能。class Base{public: virtual void Printf() = 0; virtual Base* Clone() { return 0; }private:};c

#include <iostream>using namespace std;class ProductAbase{public: ProductAbase(){} virtual ~ProductAbase(){} virtual void Printf() = 0;};class Product1 : public ProductAbase{public:

#include <iostream>using namespace std;//不知道为什么其实很好解释的东西在网上搞的人晕头转向的，以下是我的理解。//一个基类衍生出许多具体实现的子类，这些子类都实现了虚基类的公共方法，//然后我们再构造一个Direver对象，让基类做为他的成员变量，在调用的时候//可以选择任意的子类对象传入然后可以调用该子类的方法,是不是很简单呢？//“生成器模式的

#include <iostream>using namespace std;//基类。class Parent{public: virtual void Printf()=0;};class Child1 : public Parent{public: void Printf() { cout << "Child1::Printf()" <<

#include #include //interpreter解释器模式。//一个解释类对封装的行为进行公共需求解释的一种方式。using namespace std;class Contex{public: Contex(string inputstr) { InterpreterStr = inputstr; }private: string Interpreter