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

  1 #include <cstdlib>

  2 #include <iostream>

  3 

  4 using namespace std;

  5 

  6 //// brige partten:Begin

  7 class bri_Implementor

  8 { 

  9 public:

 10          virtual void optImpl() = 0;

 11 };

 12 

 13 class bri_ImplementorA: public bri_Implementor

 14 { public:

 15          void optImpl() { std::cout << "ImplementA" << std::endl; }       

 16 };

 17 

 18 class bri_Abstract

 19 { public:

 20          bri_Implementor *impl;

 21          void opt() { this->impl->optImpl(); }

 22 };

 23 

 24 void test_bridge()

 25 {

 26      bri_Abstract a;

 27      a.impl = new bri_ImplementorA();

 28      a.opt();   

 29 }

 30 //// brige partten:End

 31 

 32 //// single partten:Begin

 33 class sig_Singlon

 34 { 

 35 public:

 36       int data;

 37       static sig_Singlon * inst;

 38       

 39       static sig_Singlon& instance()

 40       {

 41              if(inst != NULL) {

 42                      return *inst;

 43              }

 44              else {

 45                  inst = new sig_Singlon();

 46                  inst->data = 3;                 

 47                  return *inst;

 48              }

 49       } // instance

 50       

 51       int get_data() { return this->data; }

 52 };

 53 //// single partten:End

 54 

 55 sig_Singlon* sig_Singlon::inst = NULL;

 56 

 57 void test_singlon()

 58 {

 59      std::cout << "Singlon Data is: " <<

 60                sig_Singlon::instance().get_data() << std::endl;     

 61 }

 62 

 63 //// builder partten:Begin

 64 class bui_Product

 65 { public:

 66 };

 67 

 68 class bui_Builder

 69 { public:

 70          virtual void buildPartA() = 0;

 71          virtual void buildPartB() = 0;

 72          virtual bui_Product getResult() = 0;

 73 };

 74 

 75 class bui_BuilderA : public bui_Builder

 76 { public:

 77          void buildPartA(){ std::cout << "BuildA::PartA" << std::endl; }

 78          void buildPartB(){ std::cout << "BuildA::PartB" << std::endl; }

 79          bui_Product getResult(){std::cout << "Build Finish!~" << std::endl;} 

 80 };

 81 

 82 class bui_Director

 83 { public:

 84          static bui_Product construct(bui_Builder * b) {

 85               b->buildPartA();

 86               b->buildPartB();

 87               return b->getResult();     

 88          } // construct       

 89 };

 90 

 91 void test_builder()

 92 {

 93      bui_Director::construct(new bui_BuilderA());

 94 }

 95 //// builder partten:End

 96 

 97 //// prototype parrten:Begin

 98 class proto_Prototype

 99 { public:

100        int *pdata;

101        proto_Prototype(int data = 0) { pdata = new int(data); }

102        proto_Prototype& clone()

103        {

104               proto_Prototype* c = new proto_Prototype();             

105               *(c->pdata) = *(this->pdata); // deeply copy.

106               return (*c);

107        } // clone           

108 }; // proto_Prototype

109 

110 void test_prototype()

111 {

112      proto_Prototype o1;

113      *(o1.pdata) = 1;

114      proto_Prototype o2(o1);

115      proto_Prototype o3 = o1.clone();

116      *(o2.pdata) = 2;

117      *(o3.pdata) = 3;

118      std::cout << "prototype object1 : " << *(o1.pdata) <<

119      " , object2: " << *(o2.pdata) <<

120      ", object3: " << *(o3.pdata) << std::endl;

121 }

122 //// prototype parrten:End

123 

124 //// adapter parrten:Begin

125 class adp_Adaptee

126 { public:

127          int simu() { std::cout << "simulation signal." << std::endl; }

128 };

129 

130 class adp_Adapter

131 { public:

132          virtual void digital() = 0;

133 };

134 

135 class adp_AdapterA

136 { public:

137          adp_Adaptee *adaptee;

138          void digital() { 

139               adaptee->simu(); 

140               std::cout << "convert to digital signal now!" << std::endl; 

141          }

142 };

143 

144 void test_adapter()

145 {

146      adp_AdapterA adp;

147      adp.adaptee = new adp_Adaptee();

148      adp.digital();

149 }

150 //// adapter parrten:End

151 

152 //// state partten:Start

153 enum STA_STATE {STA_START, STA_RUNNING, STA_FINISH, STA_EXIT};

154 

155 class sta_State

156 { public:

157      virtual void handle() = 0;        

158 };

159 

160 class sta_ConcreteStateStart: public sta_State

161 { public:

162      void handle() { std::cout << "Starting..." << std::endl; }

163 }; 

164 

165 class sta_ConcreteStateRunning: public sta_State

166 { public:

167      void handle() { std::cout << "Running..." << std::endl; }

168 }; 

169 

170 class sta_ConcreteStateFinish: public sta_State

171 { public:

172      void handle() { std::cout << "Finishing..." << std::endl; }

173 }; 

174 

175 class Context

176 {

177       enum STA_STATE state;

178       sta_State *handler;

179 public:      

180       Context() { state = STA_START; handler = NULL; }

181       void request()

182       {

183            switch(state)

184            {

185              case STA_START:{ 

186                   handler = new sta_ConcreteStateStart();

187                   handler->handle();

188                   delete handler; 

189                   state = STA_RUNNING;

190              } break;

191              case STA_RUNNING:{ 

192                   handler = new sta_ConcreteStateRunning();                  

193                   handler->handle();

194                   delete handler; 

195                   state = STA_FINISH;

196              } break;

197              case STA_FINISH:{ 

198                   handler = new sta_ConcreteStateFinish();

199                   handler->handle();

200                   delete handler;                   

201                   state = STA_EXIT;

202              } break;

203              default: {             

204                    return;

205              }

206            } // switch             

207       } // request

208 }; 

209 

210 void test_state()

211 {

212      Context context;

213      context.request();

214      context.request();

215      context.request();

216      context.request();    

217      context.request();    

218 }

219 //// state partten:End

220 

221 //// component parrten:Start

222 class com_Component

223 { public:

224       virtual void opt() = 0;

225       virtual void add(com_Component *c) {}

226       virtual void remove(com_Component *c) {}

227       virtual com_Component* getChild(int i) { return NULL; }

228 };

229 

230 class com_Leaf: public com_Component

231 { public:

232       void opt() { std::cout << "leaf" << std::endl; }

233 };

234 #include <vector>

235 #include <algorithm>

236 class com_InnerNode: public com_Component

237 { public:

238       std::vector<com_Component *> node_set;

239       void opt()

240       {

241            for(int i = 0; i < node_set.size(); ++i)

242            {

243                    std::cout << "inner->"; node_set[i]->opt();

244            } // for

245       }

246       void add(com_Component *c) { node_set.push_back(c); }

247       void remove(com_Component *c) { 

248            node_set.erase(std::remove(node_set.begin(), node_set.end(), c), node_set.end());

249       }

250       com_Component* getChild(int i) { return node_set[i]; }

251 };

252 

253 void test_component()

254 {

255      com_InnerNode *root = new com_InnerNode();

256      root->add(new com_InnerNode());

257      root->getChild(0)->add(new com_Leaf());

258      root->getChild(0)->add(new com_Leaf());

259      root->opt();

260 }

261 //// component parrten:End

262 

263 //// observer parrten:Start

264 class obs_Observer

265 { public:

266       virtual void update() = 0;

267 };

268 

269 class obs_ObserverA : public obs_Observer

270 { public:

271       void update() { std::cout << "obs_ObserverA::update()" << std::endl; }

272 };

273 

274 class obs_Subject

275 { public:

276       virtual void attach(obs_Observer *o) = 0;

277       virtual void detach(obs_Observer *&o) = 0;

278       virtual void notify() = 0;

279 };

280 

281 class obs_SubjectImplA:public obs_Subject

282 { public:      

283       obs_Observer *inst;

284       void attach(obs_Observer *o) { inst = o; }

285       void detach(obs_Observer *&o) { o = inst; inst = NULL; }

286       void notify() { inst->update(); }

287 };

288 

289 void test_observer()

290 {

291      obs_SubjectImplA subject;

292      subject.attach(new obs_ObserverA());

293      subject.notify();

294      obs_Observer *observer = NULL;

295      subject.detach(observer);

296 }

297 //// observer parrten:End

298 

299 //// vistor parrten:Start

300 class vis_Vistor;

301 class vis_Element

302 { public:

303       virtual void accept(vis_Vistor *vistor) = 0;

304 };

305 

306 class vis_ConcreteElemA : public vis_Element

307 { public:

308       int dta;

309       void accept(vis_Vistor *vistor);

310 };

311 

312 class vis_ConcreteElemB : public vis_Element

313 { public:

314       int dtb;

315       void accept(vis_Vistor *vistor);

316 };

317 

318 class vis_Vistor

319 { public:

320       void vistElemA(vis_ConcreteElemA *a) { a->dta = 911; }

321       void vistElemB(vis_ConcreteElemB *b) { b->dtb = 101; }

322 };

323 

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

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

326 

327 void test_vistor()

328 {

329      vis_ConcreteElemA a;

330      vis_ConcreteElemB b;

331      vis_Vistor *vistor = new vis_Vistor();

332      a.accept(vistor);

333      b.accept(vistor);

334      std::cout << "ElemA's Value:" << a.dta 

335                << " ,ElemB's Value:" << b.dtb << std::endl;     

336 }

337 //// vistor parrten:End

338 

339 int main(int argc, char *argv[])

340 {

341     test_vistor();

342     

343     system("PAUSE");

344     return EXIT_SUCCESS;

345 }