常见设计模式C++代码实现

#include <cstdlib>
#include <iostream>

using namespace std;

//// brige partten:Begin
class bri_Implementor
{ 
public:
         virtual void optImpl() = 0;
};

class bri_ImplementorA: public bri_Implementor
{ public:
         void optImpl() { std::cout << "ImplementA" << std::endl; }       
};

class bri_Abstract
{ public:
         bri_Implementor *impl;
         void opt() { this->impl->optImpl(); }
};

void test_bridge()
{
     bri_Abstract a;
     a.impl = new bri_ImplementorA();
     a.opt();   
}
//// brige partten:End

//// single partten:Begin
class sig_Singlon
{ 
public:
      int data;
      static sig_Singlon * inst;
      
      static sig_Singlon& instance()
      {
             if(inst != NULL) {
                     return *inst;
             }
             else {
                 inst = new sig_Singlon();
                 inst->data = 3;                 
                 return *inst;
             }
      } // instance
      
      int get_data() { return this->data; }
};
//// single partten:End

sig_Singlon* sig_Singlon::inst = NULL;

void test_singlon()
{
     std::cout << "Singlon Data is: " <<
               sig_Singlon::instance().get_data() << std::endl;     
}

//// builder partten:Begin
class bui_Product
{ public:
};

class bui_Builder
{ public:
         virtual void buildPartA() = 0;
         virtual void buildPartB() = 0;
         virtual bui_Product getResult() = 0;
};

class bui_BuilderA : public bui_Builder
{ public:
         void buildPartA(){ std::cout << "BuildA::PartA" << std::endl; }
         void buildPartB(){ std::cout << "BuildA::PartB" << std::endl; }
         bui_Product getResult(){std::cout << "Build Finish!~" << std::endl;} 
};

class bui_Director
{ public:
         static bui_Product construct(bui_Builder * b) {
              b->buildPartA();
              b->buildPartB();
              return b->getResult();     
         } // construct       
};

void test_builder()
{
     bui_Director::construct(new bui_BuilderA());
}
//// builder partten:End

//// prototype parrten:Begin
class proto_Prototype
{ public:
       int *pdata;
       proto_Prototype(int data = 0) { pdata = new int(data); }
       proto_Prototype& clone()
       {
              proto_Prototype* c = new proto_Prototype();             
              *(c->pdata) = *(this->pdata); // deeply copy.
              return (*c);
       } // clone           
}; // proto_Prototype

void test_prototype()
{
     proto_Prototype o1;
     *(o1.pdata) = 1;
     proto_Prototype o2(o1);
     proto_Prototype o3 = o1.clone();
     *(o2.pdata) = 2;
     *(o3.pdata) = 3;
     std::cout << "prototype object1 : " << *(o1.pdata) <<
     " , object2: " << *(o2.pdata) <<
     ", object3: " << *(o3.pdata) << std::endl;
}
//// prototype parrten:End

//// adapter parrten:Begin
class adp_Adaptee
{ public:
         int simu() { std::cout << "simulation signal." << std::endl; }
};

class adp_Adapter
{ public:
         virtual void digital() = 0;
};

class adp_AdapterA
{ public:
         adp_Adaptee *adaptee;
         void digital() { 
              adaptee->simu(); 
              std::cout << "convert to digital signal now!" << std::endl; 
         }
};

void test_adapter()
{
     adp_AdapterA adp;
     adp.adaptee = new adp_Adaptee();
     adp.digital();
}
//// adapter parrten:End

//// state partten:Start
enum STA_STATE {STA_START, STA_RUNNING, STA_FINISH, STA_EXIT};

class sta_State
{ public:
     virtual void handle() = 0;        
};

class sta_ConcreteStateStart: public sta_State
{ public:
     void handle() { std::cout << "Starting..." << std::endl; }
}; 

class sta_ConcreteStateRunning: public sta_State
{ public:
     void handle() { std::cout << "Running..." << std::endl; }
}; 

class sta_ConcreteStateFinish: public sta_State
{ public:
     void handle() { std::cout << "Finishing..." << std::endl; }
}; 

class Context
{
      enum STA_STATE state;
      sta_State *handler;
public:      
      Context() { state = STA_START; handler = NULL; }
      void request()
      {
           switch(state)
           {
             case STA_START:{ 
                  handler = new sta_ConcreteStateStart();
                  handler->handle();
                  delete handler; 
                  state = STA_RUNNING;
             } break;
             case STA_RUNNING:{ 
                  handler = new sta_ConcreteStateRunning();                  
                  handler->handle();
                  delete handler; 
                  state = STA_FINISH;
             } break;
             case STA_FINISH:{ 
                  handler = new sta_ConcreteStateFinish();
                  handler->handle();
                  delete handler;                   
                  state = STA_EXIT;
             } break;
             default: {             
                   return;
             }
           } // switch             
      } // request
}; 

void test_state()
{
     Context context;
     context.request();
     context.request();
     context.request();
     context.request();    
     context.request();    
}
//// state partten:End

//// component parrten:Start
class com_Component
{ public:
      virtual void opt() = 0;
      virtual void add(com_Component *c) {}
      virtual void remove(com_Component *c) {}
      virtual com_Component* getChild(int i) { return NULL; }
};

class com_Leaf: public com_Component
{ public:
      void opt() { std::cout << "leaf" << std::endl; }
};
#include <vector>
#include <algorithm>
class com_InnerNode: public com_Component
{ public:
      std::vector<com_Component *> node_set;
      void opt()
      {
           for(int i = 0; i < node_set.size(); ++i)
           {
                   std::cout << "inner->"; node_set[i]->opt();
           } // for
      }
      void add(com_Component *c) { node_set.push_back(c); }
      void remove(com_Component *c) { 
           node_set.erase(std::remove(node_set.begin(), node_set.end(), c), node_set.end());
      }
      com_Component* getChild(int i) { return node_set[i]; }
};

void test_component()
{
     com_InnerNode *root = new com_InnerNode();
     root->add(new com_InnerNode());
     root->getChild(0)->add(new com_Leaf());
     root->getChild(0)->add(new com_Leaf());
     root->opt();
}
//// component parrten:End

//// observer parrten:Start
class obs_Observer
{ public:
      virtual void update() = 0;
};

class obs_ObserverA : public obs_Observer
{ public:
      void update() { std::cout << "obs_ObserverA::update()" << std::endl; }
};

class obs_Subject
{ public:
      virtual void attach(obs_Observer *o) = 0;
      virtual void detach(obs_Observer *&o) = 0;
      virtual void notify() = 0;
};

class obs_SubjectImplA:public obs_Subject
{ public:      
      obs_Observer *inst;
      void attach(obs_Observer *o) { inst = o; }
      void detach(obs_Observer *&o) { o = inst; inst = NULL; }
      void notify() { inst->update(); }
};

void test_observer()
{
     obs_SubjectImplA subject;
     subject.attach(new obs_ObserverA());
     subject.notify();
     obs_Observer *observer = NULL;
     subject.detach(observer);
}
//// observer parrten:End

//// vistor parrten:Start
class vis_Vistor;
class vis_Element
{ public:
      virtual void accept(vis_Vistor *vistor) = 0;
};

class vis_ConcreteElemA : public vis_Element
{ public:
      int dta;
      void accept(vis_Vistor *vistor);
};

class vis_ConcreteElemB : public vis_Element
{ public:
      int dtb;
      void accept(vis_Vistor *vistor);
};

class vis_Vistor
{ public:
      void vistElemA(vis_ConcreteElemA *a) { a->dta = 911; }
      void vistElemB(vis_ConcreteElemB *b) { b->dtb = 101; }
};

void vis_ConcreteElemA::accept(vis_Vistor *vistor) { vistor->vistElemA(this); }
void vis_ConcreteElemB::accept(vis_Vistor *vistor) { vistor->vistElemB(this); }

void test_vistor()
{
     vis_ConcreteElemA a;
     vis_ConcreteElemB b;
     vis_Vistor *vistor = new vis_Vistor();
     a.accept(vistor);
     b.accept(vistor);
     std::cout << "ElemA's Value:" << a.dta 
               << " ,ElemB's Value:" << b.dtb << std::endl;     
}
//// vistor parrten:End

int main(int argc, char *argv[])
{
    test_vistor();
    
    system("PAUSE");
    return EXIT_SUCCESS;
}