命令模式

   1 #if 0
   2 
   3 #include <iostream>
   4 #include <string>
   5 using namespace std;
   6 
   7 /*
   8  * 运算基类
   9  */
  10 class Operation
  11 {
  12 public:
  13     double numberA;
  14     double numberB;
  15 public:
  16     virtual double  getResult()
  17     {
  18         return 0;
  19     }
  20 };
  21 
  22 /*
  23  * 加法运算子类
  24  */
  25 class addOperation : public Operation
  26 {
  27     double getResult()
  28     {
  29         return numberA + numberB;
  30     }
  31 };
  32 
  33  /*
  34   * 减法运算子类
  35   */
  36 class subOperation : public Operation
  37 {
  38     double getResult()
  39     {
  40         return numberA - numberB;
  41     }
  42 };
  43 
  44  /*
  45   * 乘法运算子类
  46   */
  47 class mulOperation : public Operation
  48 {
  49     double getResult()
  50     {
  51         return numberA * numberB;
  52     }
  53 };
  54 
  55  /*
  56   * 除法运算子类
  57   */
  58 class divOperation : public Operation
  59 {
  60     double getResult()
  61     {
  62         return numberA / numberB;
  63     }
  64 };
  65 
  66  /*
  67   * 简单构建工厂
  68   */
  69 class operFactory
  70 {
  71 public:
  72     static Operation *createOperation(char c)
  73     {
  74         switch (c)
  75         {
  76         case ‘+‘:
  77             return new addOperation;
  78             break;
  79         case ‘-‘:
  80             return new subOperation;
  81             break;
  82         case ‘*‘:
  83             return new mulOperation;
  84             break;
  85         case ‘/‘:
  86             return new divOperation;
  87             break;
  88         default:
  89             break;
  90         }
  91     }
  92 };
  93 
  94  /*
  95   * 客户端应用示例
  96   */
  97 void main()
  98 {
  99     Operation *oper = operFactory::createOperation(‘+‘);
 100     oper->numberA = 9;
 101     oper->numberB = 99;
 102     cout << oper->getResult() << endl;
 103 }
 104 
 105  /*
 106   * 简单工厂模式应用示例
 107   */
 108 #include <iostream>
 109 #include <cmath>
 110 #include <string>
 111 using namespace std;
 112 
 113 class CashSuper
 114 {
 115 public:
 116     virtual double acceptMoney(double money) = 0;
 117 };
 118 
 119 class CashNormal : public CashSuper
 120 {
 121 public:
 122     double acceptMoney(double money)
 123     {
 124         return money;
 125     }
 126 };
 127 
 128 class CashRebate : public CashSuper
 129 {
 130 private:
 131     double discount;
 132 public:
 133     CashRebate(double dis)
 134     {
 135         discount = dis;
 136     }
 137     double acceptMoney(double money)
 138     {
 139         return money * discount;
 140     }
 141 };
 142 
 143 
 144 class CashReturn : public CashSuper
 145 {
 146 private:
 147     double moneyCondition;
 148     double moneyReturn;
 149 public:
 150     CashReturn(double mc, double mr)
 151     {
 152         moneyCondition = mc;
 153         moneyReturn = mr;
 154     }
 155     double acceptMoney(double money)
 156     {
 157         double result = money;
 158         if (money >= moneyCondition)
 159         {
 160             result = money - floor(money / moneyCondition) * moneyReturn;
 161         }
 162         return result;
 163     }
 164 };
 165 
 166 class CashFactory
 167 {
 168 public:
 169     static CashSuper *createCashAccept(string str)
 170     {
 171         CashSuper *cs = NULL;
 172         if ("正常收费" == str)
 173         {
 174             return new CashNormal();
 175         }
 176         else if ("打9折" == str)
 177         {
 178             return new CashRebate(0.9);
 179         }
 180         else if ("满300返200" == str)
 181         {
 182             return new CashReturn(300, 200);
 183         }
 184         return cs;
 185     }
 186 };
 187 
 188 
 189 void main()
 190 {
 191     CashSuper *cs = NULL;
 192     
 193     cs = CashFactory::createCashAccept("打9折");
 194     cout << cs->acceptMoney(1000) << endl;
 195 
 196     cs = CashFactory::createCashAccept("正常收费");
 197     cout << cs->acceptMoney(1000) << endl;
 198 }
 199 
 200 
 201 
 202 
 203  /*
 204   * 策略模式
 205   */
 206 
 207 #include <iostream>
 208 #include <cmath>
 209 #include <string>
 210 using namespace std;
 211 
 212 class CashSuper
 213 {
 214 public:
 215     virtual double acceptMoney(double money) = 0;
 216 };
 217 
 218 class CashNormal : public CashSuper
 219 {
 220 public:
 221     double acceptMoney(double money)
 222     {
 223         return money;
 224     }
 225 };
 226 
 227 class CashRebate : public CashSuper
 228 {
 229 private:
 230     double discount;
 231 
 232 public:
 233     CashRebate(double dis)
 234     {
 235         discount = dis;
 236     }
 237     double acceptMoney(double money)
 238     {
 239         return money * discount;
 240     }
 241 };
 242 
 243 
 244 class CashReturn : public CashSuper
 245 {
 246 private:
 247     double moneyCondition;
 248     double moneyReturn;
 249 
 250 public:
 251     CashReturn(double mc, double mr)
 252     {
 253         moneyCondition = mc;
 254         moneyReturn = mr;
 255     }
 256     double acceptMoney(double money)
 257     {
 258         double result = money;
 259         if (money >= moneyCondition)
 260         {
 261             result = money - floor(money / moneyCondition) * moneyReturn;
 262         }
 263         return result;
 264     }
 265 };
 266 
 267 class  CashContext
 268 {
 269 private:
 270     CashSuper *cs;
 271 public:
 272     CashContext(CashSuper *cs)
 273     {
 274         this->cs = cs;
 275     }
 276     double getResult(double money)
 277     {
 278         return cs->acceptMoney(money);
 279     }
 280 };
 281 
 282 void main()
 283 {
 284     CashSuper *cs;
 285     CashContext *cc;
 286     double money = 1000;
 287 
 288     cs = new CashRebate(0.8);
 289     cc = new CashContext(cs);
 290     cout << cc->getResult(money) << endl;
 291 
 292     money = 1000;
 293     cs = new CashNormal();
 294     cc = new CashContext(cs);
 295     cout << cc->getResult(money) << endl;
 296 
 297 }
 298 
 299 
 300 
 301  /*
 302   * 策略与工厂模式
 303   */
 304 #include <iostream>
 305 #include <cmath>
 306 #include <string>
 307 using namespace std;
 308 
 309 class CashSuper
 310 {
 311 public:
 312     virtual double acceptMoney(double money) = 0;
 313 };
 314 
 315 class CashNormal : public CashSuper
 316 {
 317 public:
 318     double acceptMoney(double money)
 319     {
 320         return money;
 321     }
 322 };
 323 
 324 class CashRebate : public CashSuper
 325 {
 326 private:
 327     double discount;
 328 public:
 329     CashRebate(double dis)
 330     {
 331         discount = dis;
 332     }
 333     double acceptMoney(double money)
 334     {
 335         return money * discount;
 336     }
 337 };
 338 
 339 
 340 class CashReturn : public CashSuper
 341 {
 342 private:
 343     double moneyCondition;
 344     double moneyReturn;
 345 public:
 346     CashReturn(double mc, double mr)
 347     {
 348         moneyCondition = mc;
 349         moneyReturn = mr;
 350     }
 351     double acceptMoney(double money)
 352     {
 353         double result = money;
 354         if (money >= moneyCondition)
 355         {
 356             result = money - floor(money / moneyCondition) * moneyReturn;
 357         }
 358         return result;
 359     }
 360 };
 361 
 362 class  CashContext
 363 {
 364 private:
 365     CashSuper *cs;
 366 public:
 367     CashContext(string str)
 368     {
 369         if ("正常收费" == str)
 370         {
 371             cs = new CashNormal();
 372         }
 373         else if ("打9折" == str)
 374         {
 375             cs = new CashRebate(0.9);
 376         }
 377         else if ("满300送200" == str)
 378         {
 379             cs = new CashReturn(300, 200);
 380         }        
 381     }
 382     double getResult(double money)
 383     {
 384         return cs->acceptMoney(money);
 385     }
 386 };
 387 
 388 
 389 int main()
 390 {
 391     double money = 1000;
 392     CashContext *cc = new CashContext("打9折");
 393     cout << cc->getResult(money);
 394     return 0;
 395 }
 396 
 397 
 398 #include <string>
 399 #include <iostream>
 400 using namespace std;
 401 
 402 class Person
 403 {
 404 private:
 405     string m_strName;
 406 public:
 407     Person(string strName)
 408     {
 409         m_strName = strName;
 410     }
 411 
 412     Person(){}
 413 
 414     virtual void show()
 415     {
 416         cout << "装扮的是:" << m_strName << endl;
 417     }
 418 };    
 419 
 420 class Finery : public Person
 421 {
 422 protected:
 423     Person *m_component;
 424 public:
 425     void decorate(Person* component)
 426     {
 427         m_component = component;
 428     }
 429     virtual void show()
 430     {
 431         m_component->show();
 432     }
 433 };
 434 
 435 class TShirts : public Finery
 436 {
 437 public:
 438     virtual void show()
 439     {
 440         m_component->show();
 441         cout << "T shirts" << endl;
 442     }
 443 };
 444 
 445 class BigTrouser : public Finery
 446 {
 447 public:
 448     virtual void show()
 449     {
 450         m_component->show();
 451         cout << "Big Trouser" << endl;
 452     }
 453 };
 454 
 455 int main()
 456 {
 457     Person *p = new Person("小李");
 458     BigTrouser *bt = new BigTrouser();
 459     TShirts *ts = new TShirts();
 460         
 461     bt->decorate(p);
 462     ts->decorate(bt);
 463     ts->show();
 464 
 465     return 0;
 466 }
 467 
 468 #include <iostream>
 469 #include <string>
 470 using namespace std;
 471 
 472 class SchoolGirl
 473 {
 474 public:
 475     string name;
 476 };
 477 
 478 /*
 479  * 接口
 480  */
 481 class IGiveGift
 482 {
 483 public:
 484     virtual void giveDolls() = 0;
 485     virtual void giveFlowers() = 0;
 486 };
 487 
 488 /*
 489  * 委托类
 490  */
 491 class Pursuit : public IGiveGift
 492 {
 493 private:
 494     SchoolGirl mm;
 495 
 496 public:
 497     Pursuit(SchoolGirl m)
 498     {
 499         mm = m;
 500     }
 501     void giveDolls()
 502     {
 503         cout << mm.name << " 送你娃娃" << endl;    
 504     }
 505     void giveFlowers()
 506     {
 507         cout << mm.name << " 送你鲜花" << endl;    
 508     }
 509 };
 510 
 511 /*
 512  * 代理类
 513  */
 514 class Proxy : public IGiveGift
 515 {
 516 private:
 517     Pursuit gg;
 518 
 519 public:
 520     Proxy(SchoolGirl mm) : gg(mm)
 521     {
 522     }
 523     void giveDolls()
 524     {
 525         gg.giveDolls();
 526     }
 527     void giveFlowers()
 528     {
 529         gg.giveFlowers();
 530     }
 531 };
 532 
 533 /*
 534  * 客户端
 535  */
 536 int main()
 537 {
 538     SchoolGirl lijiaojiao;
 539     lijiaojiao.name = "李娇娇"; 
 540     Pursuit zhuojiayi(lijiaojiao); 
 541     Proxy daili(lijiaojiao);
 542 
 543     daili.giveDolls();
 544     daili.giveFlowers();
 545 
 546     return 0;
 547 }
 548 
 549 #include <iostream>
 550 #include <string>
 551 using namespace std;
 552 
 553 class Operation
 554 {
 555 public:
 556     double numberA;
 557     double numberB;
 558 
 559     virtual double getResult()
 560     {
 561         return 0;
 562     }
 563 };
 564 
 565 class addOperation : public Operation
 566 {
 567     double getResult()
 568     {
 569         return numberA + numberB;
 570     }
 571 };
 572 
 573  
 574 class subOperation : public Operation
 575 {
 576     double getResult()
 577     {
 578         return numberA - numberB;
 579     }
 580 };
 581 
 582 class mulOperation : public Operation
 583 {
 584     double getResult()
 585     {
 586         return numberA * numberB;
 587     }
 588 };
 589 
 590 class divOperation : public Operation
 591 {
 592     double getResult()
 593     {
 594         return numberA / numberB;
 595     }
 596 };
 597 
 598 class IFactory
 599 {
 600 public:
 601     virtual Operation *createOperation() = 0;
 602 };
 603 
 604 class AddFactory : public IFactory
 605 {
 606 public:
 607     static Operation *createOperation()
 608     {
 609         return new addOperation();
 610     }
 611 };
 612 
 613 
 614 class SubFactory : public IFactory
 615 {
 616 public:
 617     static Operation *createOperation()
 618     {
 619         return new subOperation();
 620     }
 621 };
 622 
 623 class MulFactory : public IFactory
 624 {
 625 public:
 626     static Operation *createOperation()
 627     {
 628         return new mulOperation();
 629     }
 630 };
 631 
 632 class DivFactory : public IFactory
 633 {
 634 public:
 635     static Operation *createOperation()
 636     {
 637         return new divOperation();
 638     }
 639 };
 640 
 641 int main()
 642 {
 643     Operation *oper = MulFactory::createOperation();
 644     oper->numberA = 9;
 645     oper->numberB = 99;
 646     cout << oper->getResult() << endl;
 647     return 0;
 648 }
 649 
 650 #include <iostream>
 651 #include <string>
 652 using namespace std;
 653 
 654 class Prototype
 655 {
 656 private:
 657     string str;
 658 public:
 659     Prototype(string s)
 660     {
 661         str = s;
 662     }
 663     Prototype()
 664     {
 665         str = "";
 666     }
 667     void show()
 668     {
 669         cout << str << endl;
 670     }
 671     virtual Prototype *clone() = 0;
 672 };
 673 
 674 class ConcretePrototype1 : public Prototype
 675 {
 676 public:
 677     ConcretePrototype1(string s) : Prototype(s)
 678     {}
 679     ConcretePrototype1(){}
 680     virtual Prototype *clone()
 681     {
 682         ConcretePrototype1 *p = new ConcretePrototype1();
 683         *p = *this;
 684         return p;
 685     }
 686 };
 687 
 688 
 689 class ConcretePrototype2 : public Prototype
 690 {
 691 public:
 692     ConcretePrototype2(string s) : Prototype(s)
 693     {}
 694     ConcretePrototype2(){}
 695     virtual Prototype *clone()
 696     {
 697         ConcretePrototype2 *p = new ConcretePrototype2();
 698         *p = *this;
 699         return p;
 700     }
 701 };
 702 
 703 int main()
 704 {
 705     ConcretePrototype1 *test = new ConcretePrototype1("小李");
 706     ConcretePrototype2 *test2 = (ConcretePrototype2 *)test->clone();
 707     test->show();
 708     test2->show();
 709     return 0;
 710 }
 711 
 712 #include <iostream>
 713 #include <string>
 714 using namespace std;
 715  
 716 class Resume
 717 {
 718 private:
 719     string name, sex, age, timeArea, company;
 720 public:
 721     Resume(string s)
 722     {
 723         name = s;
 724     }
 725     void setPersonalInfo(string s, string a)
 726     {
 727         sex = s;
 728         age = a;
 729     }
 730     void setWorkExperience(string t, string c)
 731     {
 732         timeArea = t;
 733         company = c;
 734     }
 735     void display()
 736     {
 737         cout << name << "  " << sex << "  " << age << endl;
 738         cout << "工作经历:  " << timeArea << "  " << company << endl;
 739 
 740     }
 741     Resume *clone()
 742     {
 743         Resume *b = new Resume(name);
 744         b->setPersonalInfo(sex, age);
 745         b->setWorkExperience(timeArea, company);
 746         return b;
 747     }
 748 };
 749 
 750 
 751 int main()
 752 {
 753     Resume *r = new Resume("李俊宏");      
 754     r->setPersonalInfo("男","26");
 755     r->setWorkExperience("2007-2010","读研究生");
 756     r->display();
 757     
 758 
 759     Resume *r2 = r->clone();
 760     r2->setWorkExperience("2003-2007","读本科");
 761     
 762     r->display();
 763     r2->display();
 764     
 765     return 0;
 766 }
 767 
 768 #include <iostream>
 769 #include <string>
 770 using namespace std;
 771 
 772 class TestPaper
 773 {
 774 public:
 775     void question1()
 776     {
 777         cout << "1+1=" << answer1() << endl;
 778     }
 779     void question2()
 780     {
 781         cout << "1*1=" << answer2() << endl;
 782     }
 783     virtual string answer1()
 784     {
 785         return "";
 786     }
 787     virtual string answer2()
 788     {
 789         return "";
 790     }
 791     virtual ~TestPaper()
 792     {
 793     }
 794 };
 795 
 796 class TestPaperA : public TestPaper
 797 {
 798 public:
 799     string answer1()
 800     {
 801         return "2";
 802     }
 803     virtual string answer2()
 804     {
 805         return "1";
 806     }
 807 };
 808 
 809 class TestPaperB : public TestPaper
 810 {
 811 public:
 812     string answer1()
 813     {
 814         return "3";
 815     }
 816     virtual string answer2()
 817     {
 818         return "4";
 819     }
 820 };
 821 
 822 
 823 int main()
 824 {
 825     cout << "A的试卷:" << endl;
 826     TestPaper *s1 = new TestPaperA();
 827     s1->question1();
 828     s1->question2();
 829     delete s1;
 830 
 831     cout << endl;
 832     cout << "B的试卷:" << endl;
 833     TestPaper *s2 = new TestPaperB();
 834     s2->question1();
 835     s2->question2();
 836 
 837     return 0;
 838 }
 839 
 840 #include<iostream>
 841 #include <vector>
 842 #include <string>
 843 using namespace std;
 844 
 845 class AbstractClass
 846 {
 847 public:
 848     void Show()
 849     {
 850         cout << "我是" << GetName() << endl;
 851     }
 852 protected:
 853     virtual string GetName() = 0;
 854 };
 855 
 856 class Naruto : public AbstractClass
 857 {
 858 protected:
 859     virtual string GetName()
 860     {
 861         return "火影史上最帅的六代目---一鸣惊人naruto";
 862     }
 863 };
 864 
 865 class OnePice : public AbstractClass
 866 {
 867 protected:
 868     virtual string GetName()
 869     {
 870         return "我是无恶不做的大海贼---路飞";
 871     }
 872 };
 873 
 874 //客户端
 875 int main()
 876 {
 877     Naruto* man = new Naruto();
 878     man->Show();
 879 
 880     OnePice* man2 = new OnePice();
 881     man2->Show();
 882 
 883     return 0;
 884 }
 885 
 886 #include <iostream>
 887 #include <string>
 888 using namespace std;
 889 
 890 class Sub1
 891 {
 892 public:
 893     void f1()
 894     {
 895         cout << "子系统的方法 1" << endl;
 896     }
 897 };
 898 
 899 class Sub2
 900 {
 901 public:
 902     void f2()
 903     {
 904         cout << "子系统的方法 2" << endl;
 905     }
 906 };
 907 
 908 class Sub3
 909 {
 910 public:
 911     void f3()
 912     {
 913         cout << "子系统的方法 3" << endl;
 914     }
 915 };
 916 
 917 class Facade
 918 {
 919 private:
 920     Sub1 *s1;
 921     Sub2 *s2;
 922     Sub3 *s3;
 923 public:
 924     Facade()
 925     {
 926         s1 = new Sub1();
 927         s2 = new Sub2();
 928         s3 = new Sub3();
 929     }
 930 
 931     void method()
 932     {
 933         s1->f1();
 934         s2->f2();
 935         s3->f3();
 936     }
 937 
 938     ~Facade()
 939     {
 940         if (s1)
 941             delete s1;
 942         if (s2)
 943             delete s2;
 944         if (s3)
 945             delete s3;
 946     }
 947 };
 948 
 949 int main()
 950 {
 951     Facade *f = new Facade();
 952     f->method();
 953     return 0;
 954 }
 955 
 956 #include <string>
 957 #include <iostream>
 958 #include <vector>
 959 using namespace std;
 960 
 961 class Person
 962 {
 963 public:
 964     virtual void createHead() = 0;
 965     virtual void createHand() = 0;
 966     virtual void createBody() = 0;
 967     virtual void createFoot() = 0;
 968 };
 969 
 970 class ThinPerson : public Person
 971 {
 972     void createHead()
 973     {
 974         cout << "thin head" << endl;
 975     }
 976     void createHand()
 977     {
 978         cout << "thin hand" << endl;
 979     }
 980     void createBody()
 981     {
 982         cout << "thin body" << endl;
 983     }
 984     void createFoot()
 985     {
 986         cout << "thin foot" << endl;
 987     }
 988 };
 989 
 990 class FatPerson : public Person
 991 {
 992     void createHead()
 993     {
 994         cout << "fat head" << endl;
 995     }
 996     void createHand()
 997     {
 998         cout << "fat hand" << endl;
 999     }
1000     void createBody()
1001     {
1002         cout << "fat body" << endl;
1003     }
1004     void createFoot()
1005     {
1006         cout << "fat foot" << endl;
1007     }
1008 };
1009 
1010 
1011 class Director
1012 {
1013 private:
1014     Person *p;
1015 public:
1016     Director(Person *temp)
1017     {
1018         p = temp;
1019     }
1020     void create()
1021     {
1022         p->createHead();
1023         p->createHand();
1024         p->createBody();
1025         p->createFoot();
1026     }
1027 };
1028 
1029 //客户端代码：
1030 int main()
1031 {
1032     Person *p = new FatPerson();
1033     Person *b = new ThinPerson();
1034     Director *d = new Director(p);
1035     Director *s = new Director(b);
1036     d->create();
1037     s->create();
1038     delete d;
1039     delete p;
1040     delete s;
1041     delete b;
1042 
1043     return 0;
1044 }
1045 
1046 #include <string>
1047 #include <iostream>
1048 #include <vector>
1049 using namespace std;
1050 
1051 class Product
1052 {
1053 private:
1054     vector<string> product;
1055 public:
1056     void add(string str)
1057     {
1058         product.push_back(str);
1059     }
1060     void show()
1061     {
1062         vector<string>::iterator iter = product.begin();
1063         while (iter != product.end())
1064         {
1065             cout << *iter << "  ";
1066             ++iter;
1067         }
1068         cout << endl;
1069     }
1070 };
1071 
1072 class Builder
1073 {
1074 public:
1075     virtual void builderA() = 0;
1076     virtual void builderB() = 0;
1077     virtual Product *getResult() = 0;
1078 };
1079 
1080 class ConcreteBuilder1 : public Builder
1081 {
1082 private:
1083     Product *product;
1084 public:
1085     ConcreteBuilder1()
1086     {
1087         product = new Product();
1088     }
1089     virtual void builderA()
1090     {
1091         product->add("one");
1092     }
1093     virtual void builderB()
1094     {
1095         product->add("two");
1096     }
1097     virtual Product *getResult()
1098     {
1099         return product;
1100     }
1101 };
1102 
1103 
1104 class ConcreteBuilder2 : public Builder
1105 {
1106 private:
1107     Product *product;
1108 public:
1109     ConcreteBuilder2()
1110     {
1111         product = new Product();
1112     }
1113     virtual void builderA()
1114     {
1115         product->add("A");
1116     }
1117     virtual void builderB()
1118     {
1119         product->add("B");
1120     }
1121     virtual Product *getResult()
1122     {
1123         return product;
1124     }
1125 };
1126 
1127 class Director
1128 {
1129 private:
1130     Product *p;
1131 public:
1132     void construct(Builder *bd)
1133     {
1134         bd->builderA();
1135         bd->builderB();
1136         p = bd->getResult();
1137     }
1138     Product *getResult()
1139     {
1140         return p;
1141     }
1142 };
1143 
1144 int main()
1145 {
1146     Director *director = new Director();
1147 
1148     Builder *bd1 = new ConcreteBuilder1();
1149     director->construct(bd1);
1150     Product *pbd1 = director->getResult();
1151 
1152     pbd1->show();
1153 
1154     return 0;
1155 }
1156 
1157 // 观察者模式
1158 
1159 #include <iostream>
1160 #include <string>
1161 #include <list>
1162 using namespace std;
1163 
1164 class Observer;
1165 
1166 class Subject
1167 {
1168 protected:
1169     list<Observer*> observers;
1170 public:
1171     string action;
1172 public:
1173     virtual void attach(Observer*) = 0;
1174     virtual void detach(Observer*) = 0;
1175     virtual void notify() = 0;
1176 };
1177 
1178 class Observer
1179 {
1180 protected:
1181     string name;
1182     Subject *sub;
1183 public:
1184     Observer(string name, Subject *sub)
1185     {
1186         this->name = name;
1187         this->sub = sub;
1188     }
1189     string getName()
1190     {
1191         return name;
1192     }
1193     virtual void update() = 0;
1194 };
1195 
1196 class StockObserver : public Observer
1197 {
1198 public:
1199     StockObserver(string name, Subject *sub) : Observer(name, sub)
1200     {
1201     }
1202     void update();
1203 };
1204 
1205 void StockObserver::update()
1206 {
1207     cout << name << " 收到消息：" << sub->action << endl;
1208     if (sub->action == "梁所长来了!")
1209     {
1210         cout << "我马上关闭股票，装做很认真工作的样子！" << endl;
1211     }
1212 }
1213 
1214 class NBAObserver : public Observer
1215 {
1216 public:
1217     NBAObserver(string name, Subject *sub) : Observer(name, sub)
1218     {
1219     }
1220     void update();
1221 };
1222 
1223 void NBAObserver::update()
1224 {
1225     cout << name << " 收到消息：" << sub->action << endl;
1226     if (sub->action == "梁所长来了!")
1227     {
1228         cout << "我马上关闭NBA，装做很认真工作的样子！" << endl;
1229     }
1230 }
1231 
1232 class Secretary : public Subject
1233 {
1234     void attach(Observer *observer)
1235     {
1236         observers.push_back(observer);
1237     }
1238     void detach(Observer *observer)
1239     {
1240         list<Observer *>::iterator iter = observers.begin();
1241         while (iter != observers.end())
1242         {
1243             if ((*iter) == observer)
1244             {
1245                 cout << "erase:" << observer->getName() << endl;
1246                 observers.erase(iter++);
1247             }
1248             else
1249             {
1250                 ++iter;
1251             }
1252         }
1253     }
1254     void notify()
1255     {
1256         list<Observer *>::iterator iter = observers.begin();
1257         while (iter != observers.end())
1258         {
1259             (*iter)->update();
1260             ++iter;
1261         }
1262     }
1263 };
1264 
1265 
1266 int main()
1267 {
1268     Subject *dwq = new Secretary();
1269 
1270     Observer *xs = new NBAObserver("xiaoshuai", dwq);
1271     Observer *zy = new NBAObserver("zouyue", dwq);
1272     Observer *lm = new StockObserver("limin", dwq);
1273 
1274     dwq->attach(xs);
1275     dwq->attach(zy);
1276     dwq->attach(lm);
1277 
1278     dwq->action = "去吃饭了！";
1279     dwq->notify();
1280     cout << endl;
1281 
1282     dwq->action = "梁所长来了!";
1283     dwq->notify();
1284 
1285     dwq->detach(lm);
1286     dwq->detach(zy);
1287     dwq->detach(xs);
1288 
1289     return 0;
1290 }
1291 
1292 #include <iostream>
1293 #include <string>
1294 using namespace std;
1295 
1296 class IUser
1297 {
1298 public:
1299     virtual void getUser() = 0;
1300     virtual void setUser() = 0;
1301 };
1302 
1303 class SqlUser : public IUser
1304 {
1305 public:
1306     void getUser()
1307     {
1308         cout << "在sql中返回user" << endl;
1309     }
1310     void setUser()
1311     {
1312         cout << "在sql中设置user" << endl;
1313     }
1314 };
1315 
1316 class AccessUser : public IUser
1317 {
1318 public:
1319     void getUser()
1320     {
1321         cout << "在Access中返回user" << endl;
1322     }
1323     void setUser()
1324     {
1325         cout << "在Access中设置user" << endl;
1326     }
1327 };
1328 
1329 class IDepartment
1330 {
1331 public:
1332     virtual void getDepartment() = 0;
1333     virtual void setDepartment() = 0;
1334 };
1335 
1336 class SqlDepartment : public IDepartment
1337 {
1338 public:
1339     void getDepartment()
1340     {
1341         cout << "在sql中返回Department" << endl;
1342     }
1343     void setDepartment()
1344     {
1345         cout << "在sql中设置Department" << endl;
1346     }
1347 };
1348 
1349 class AccessDepartment : public IDepartment
1350 {
1351 public:
1352     void getDepartment()
1353     {
1354         cout << "在Access中返回Department" << endl;
1355     }
1356     void setDepartment()
1357     {
1358         cout << "在Access中设置Department" << endl;
1359     }
1360 };
1361 
1362 class IFactory
1363 {
1364 public:
1365     virtual IUser *createUser() = 0;
1366     virtual IDepartment *createDepartment() = 0;
1367 };
1368 
1369 class SqlFactory : public IFactory
1370 {
1371 public:
1372     IUser *createUser() 
1373     {
1374         return new SqlUser();
1375     }
1376     IDepartment *createDepartment() 
1377     {
1378         return new SqlDepartment();
1379     }
1380 };
1381 
1382 class AccessFactory : public IFactory
1383 {
1384 public:
1385     IUser *createUser()
1386     {
1387         return new AccessUser();
1388     }
1389     IDepartment *createDepartment() 
1390     {
1391         return new AccessDepartment();
1392     }
1393 };
1394 
1395 /*************************************************************/
1396 
1397 class DataAccess
1398 {
1399 private:
1400     static string db;
1401 public:
1402     static IUser *createUser()
1403     {
1404         if (db == "access")
1405         {
1406             return new AccessUser();
1407         }
1408         else if (db == "sql")
1409         {
1410             return new SqlUser();
1411         }
1412     }
1413     static IDepartment *createDepartment()
1414     {
1415         if (db == "access")
1416         {
1417             return new AccessDepartment();
1418         }
1419         else if (db == "sql")
1420         {
1421             return new SqlDepartment();
1422         }    
1423     }
1424 };
1425 
1426 string DataAccess::db = "sql";
1427 
1428 /*************************************************************/
1429 
1430 int main()
1431 {
1432     IFactory *factory;
1433     IUser *user;
1434     IDepartment *department;
1435 
1436     factory = new AccessFactory();
1437     user = factory->createUser();
1438     department = factory->createDepartment();
1439     
1440     user->getUser();
1441     user->setUser();
1442     department->getDepartment();
1443     department->setDepartment();
1444 
1445     user = DataAccess::createUser();
1446     department = DataAccess::createDepartment();
1447 
1448     user->getUser();
1449     user->setUser();
1450     department->getDepartment();
1451     department->setDepartment();
1452 
1453     return 0;
1454 }
1455 
1456 #include <iostream>
1457 #include <string>
1458 using namespace std;
1459 
1460 class Work;
1461 class State;
1462 class ForenonnState;
1463 
1464 
1465 class State
1466 {
1467 public:
1468     virtual void writeProgram(Work*) = 0;
1469 };
1470 
1471 class Work
1472 {
1473 public:
1474     int hour;
1475     State *current;
1476     Work();
1477     void writeProgram()
1478     {
1479         current->writeProgram(this);
1480     }
1481 };
1482 
1483 class EveningState : public State
1484 {
1485 public:
1486     void writeProgram(Work *w)
1487     {
1488         cout << "当前时间: " << w->hour << "心情很好，在看《明朝那些事儿》，收获很大！" << endl;
1489     }
1490 };
1491 
1492 class AfternoonState : public State
1493 {
1494 public:
1495     void writeProgram(Work *w)
1496     {
1497         if (w->hour < 19)
1498         {
1499             cout << "当前时间: " << w->hour << "下午午睡后，工作还是精神百倍!" << endl;
1500         }
1501         else
1502         {
1503             w->current = new EveningState();
1504             w->writeProgram();
1505         }
1506     }
1507 };
1508 
1509 class ForenonnState : public State
1510 {
1511 public:
1512     void writeProgram(Work *w)
1513     {
1514         if (w->hour < 12)
1515         {
1516             cout << "当前时间: " << w->hour << "上午工作精神百倍!" << endl;
1517         }
1518         else
1519         {
1520             w->current = new AfternoonState();
1521             w->writeProgram();
1522         }
1523     }
1524 };
1525 
1526 Work::Work()
1527 {
1528     current = new ForenonnState();
1529 }
1530 
1531 int main()
1532 {
1533     Work *w = new Work();
1534     w->hour = 21;
1535     w->writeProgram();
1536     return 0;
1537 }
1538 //Reuslt:
1539 //当前时间: 21心情很好，在看《明朝那些事儿》，收获很大！
1540 
1541 #include <iostream>
1542 #include <string>
1543 using namespace std;
1544 
1545 class Adaptee
1546 {
1547 public:
1548     virtual void myRequest()
1549     {
1550         cout << "实际上的接口" << endl;
1551     }
1552 };
1553 
1554 class Target
1555 {
1556 public:
1557     virtual void request() = 0;
1558     virtual ~Target(){}
1559 };
1560 
1561 class Adapter : public Target
1562 {
1563 private:
1564     Adaptee adaptee;
1565 public:
1566     void request()
1567     {
1568         adaptee.myRequest();
1569     }
1570 };
1571 
1572 int main()
1573 {
1574     Target *target = new Adapter();
1575     target->request();
1576     delete target;
1577     return 0;
1578 }
1579 //Result:
1580 //实际上的接口
1581 
1582 #include <iostream>
1583 #include <string>
1584 using namespace std;
1585 
1586 class Player
1587 {
1588 public:
1589     string name;
1590     Player(string name)
1591     {
1592         this->name = name;
1593     }
1594     virtual void attack() = 0;
1595     virtual void defence() = 0;
1596 }; 
1597 
1598 class Forwards : public Player
1599 {
1600 public:
1601     Forwards(string name) : Player(name){}
1602     void attack()
1603     {
1604         cout << name << "前锋进攻" << endl;
1605     }
1606     void defence()
1607     {
1608         cout << name << "前锋防守" << endl;
1609     }
1610 };
1611 
1612 class Center : public Player
1613 {
1614 public:
1615     Center(string name) : Player(name){}
1616     void attack()
1617     {
1618         cout << name << "中锋进攻" << endl;
1619     }
1620     void defence()
1621     {
1622         cout << name << "中锋防守" << endl;
1623     }
1624 };
1625 
1626 class Backwards : public Player
1627 {
1628 public:
1629     Backwards(string name) : Player(name){}
1630     void attack()
1631     {
1632         cout << name << "后卫进攻" << endl;
1633     }
1634     void defence()
1635     {
1636         cout << name << "后卫防守" << endl;
1637     }
1638 };
1639 /*****************************************************************/
1640 class ForeignCenter
1641 {
1642 public:
1643     string name;
1644     ForeignCenter(string name)
1645     {
1646         this->name = name;
1647     }
1648     void myAttack()
1649     {
1650         cout << name << "外籍中锋进攻" << endl;
1651     }
1652     void myDefence()
1653     {
1654         cout << name << "外籍中锋防守" << endl;
1655     }
1656 };
1657 /*****************************************************************/
1658 class Translator : public Player
1659 {
1660 private:
1661     ForeignCenter *fc;
1662 public:
1663     Translator(string name) : Player(name)
1664     {
1665         fc = new ForeignCenter(name); 
1666     }
1667     void attack()
1668     {
1669         fc->myAttack();
1670     }
1671     void defence()
1672     {
1673         fc->myDefence();
1674     }
1675 };
1676 /*****************************************************************/
1677 int main()
1678 {
1679     Player *p1 = new Center("李俊宏");
1680     p1->attack();
1681     p1->defence();
1682     
1683     Translator *tl = new Translator("姚明");
1684     tl->attack();
1685     tl->defence();
1686     
1687     return 0;
1688 }
1689 //Result:
1690 /*
1691 李俊宏中锋进攻
1692 李俊宏中锋防守
1693 姚明外籍中锋进攻
1694 姚明外籍中锋防守
1695 */
1696 
1697 
1698 #include <iostream>
1699 #include <string>
1700 #include <vector>
1701 using namespace std;
1702 
1703 class Memo
1704 {
1705 public:
1706     string state;
1707     Memo(string state)
1708     {
1709         this->state = state;
1710     }
1711 };
1712 
1713 class Originator
1714 {
1715 public:
1716     string state;
1717     void setMemo(Memo *memo)
1718     {
1719         state = memo->state;
1720     }
1721     Memo *createMemo()
1722     {
1723         return new Memo(state);
1724     }
1725     void show()
1726     {
1727         cout << state << endl;
1728     }
1729 };    
1730 
1731 class Caretaker
1732 {
1733 public:
1734     vector<Memo *> memo;
1735 public:
1736     void save(Memo *memo)
1737     {
1738         (this->memo).push_back(memo);
1739     }
1740     Memo *getState(int i)
1741     {
1742         return memo[i];
1743     }
1744 };
1745  
1746 int main()
1747 {
1748     Originator *og = new Originator();
1749     Caretaker *ct = new Caretaker(); 
1750 
1751     og->state = "on";
1752     og->show();    
1753     ct->save(og->createMemo());
1754 
1755     og->state = "off";
1756     og->show();
1757     ct->save(og->createMemo());
1758 
1759     og->state = "middle";
1760     og->show();
1761     ct->save(og->createMemo());
1762 
1763     og->setMemo( ct->getState(1) );
1764     og->show();
1765 
1766     return 0;
1767 }
1768 //Result:
1769 /*
1770 on
1771 off
1772 middle
1773 off
1774 */
1775 
1776 #include <iostream>
1777 #include <vector>
1778 #include <string>
1779 using namespace std;
1780 
1781 class Component
1782 {
1783 public:
1784     string name;
1785     Component(string name)
1786     {
1787         this->name = name;
1788     }
1789     virtual void add(Component *) = 0;
1790     virtual void remove(Component *) = 0;
1791     virtual void display(int) = 0;
1792 };
1793 
1794 class Leaf : public Component
1795 {
1796 public:
1797     Leaf(string name) : Component(name)
1798     {}
1799     void add(Component *c)
1800     {
1801         cout << "leaf cannot add" << endl;
1802     }
1803     void remove(Component *c)
1804     {
1805         cout << "leaf cannot remove" << endl;
1806     }
1807     void display(int depth)
1808     {
1809         string str(depth, ‘-‘);
1810         str += name;
1811         cout << str << endl;
1812     }
1813 };
1814 
1815 class Composite : public Component
1816 {
1817 private:
1818     vector<Component*> component;
1819 public:
1820     Composite(string name) : Component(name)
1821     {}
1822     void add(Component *c)
1823     {
1824         component.push_back(c);
1825     }
1826     void remove(Component *c)
1827     {
1828         vector<Component*>::iterator iter = component.begin();
1829         while (iter != component.end())
1830         {
1831             if (*iter == c)
1832             {
1833                 component.erase(iter++);
1834             }
1835             else
1836             {
1837                 iter++;
1838             }
1839         }
1840     }
1841     void display(int depth)
1842     {
1843         string str(depth, ‘-‘);
1844         str += name;
1845         cout << str << endl;
1846 
1847         vector<Component*>::iterator iter=component.begin();
1848         while (iter != component.end())
1849         {
1850             (*iter)->display(depth + 2);
1851             iter++;
1852         }
1853     }
1854 };
1855 
1856 
1857 int main()
1858 {
1859     Component *p = new Composite("小李"); 
1860     p->add(new Leaf("小王"));
1861     p->add(new Leaf("小强"));
1862 
1863     Component *sub = new Composite("小虎"); 
1864     sub->add(new Leaf("小王"));
1865     sub->add(new Leaf("小明"));
1866     sub->add(new Leaf("小柳"));
1867     
1868     p->add(sub);
1869     p->display(0);
1870 
1871     cout << "*******" << endl;
1872     sub->display(2);
1873 
1874     return 0;
1875 }
1876 //Result:
1877 /*
1878 小李
1879 --小王
1880 --小强
1881 --小虎
1882 ----小王
1883 ----小明
1884 ----小柳
1885 *******
1886 --小虎
1887 ----小王
1888 ----小明
1889 ----小柳
1890 */
1891 
1892 #include <iostream>
1893 #include <string>
1894 using namespace std;
1895 
1896 class Iterator;
1897 
1898 class Aggregate
1899 {
1900 public:
1901     virtual Iterator *createIterator() = 0;
1902 };
1903 
1904 class Iterator
1905 {
1906 public:
1907     virtual void first() = 0;
1908     virtual void next() = 0;
1909     virtual bool isDone() = 0;
1910 };
1911 
1912 class ConcreteAggregate : public Iterator
1913 {
1914 public:
1915     void first()
1916     {}
1917     void next()
1918     {}
1919     bool isDone()
1920     {}
1921 };
1922 
1923 int main()
1924 {
1925     return 0;
1926 }
1927 
1928 #include <iostream>
1929 #include <string>
1930 using namespace std;
1931 
1932 class Singleton
1933 {    
1934 private:
1935     int i;
1936     static Singleton *instance;
1937     Singleton(int i)
1938     {
1939         this->i = i;
1940     }
1941 public:
1942     static Singleton *getInstance()
1943     {
1944         return instance;
1945     }
1946     void show()
1947     { 
1948         cout << i << endl;
1949     }
1950 };
1951 
1952 Singleton* Singleton::instance = new Singleton(8899); 
1953 
1954 class A : public Singleton
1955 {
1956 
1957 };
1958 
1959 int main()
1960 {
1961     Singleton *s = Singleton::getInstance();
1962     Singleton *s2 = A::getInstance();
1963     cout << s << endl;
1964     cout << s2 << endl;
1965     cout << (s == s2) << endl;
1966     return 0;
1967 }
1968 
1969 #include <iostream>
1970 #include <string>
1971 using namespace std;
1972 
1973 class HandsetSoft
1974 {
1975 public:
1976     virtual void run() = 0;
1977 };
1978 
1979 class HandsetGame : public HandsetSoft
1980 {
1981 public:
1982     void run()
1983     {
1984         cout << "运行手机游戏" << endl;
1985     }
1986 };
1987 
1988 class HandsetAddressList : public HandsetSoft
1989 {
1990 public:
1991     void run()
1992     {
1993         cout << "运行手机通讯录" << endl;
1994     }
1995 };
1996 
1997 class HandsetBrand
1998 {
1999 protected:
2000     HandsetSoft *soft;
2001 public:
2002     void setHandsetSoft(HandsetSoft *soft)
2003     {
2004         this->soft = soft;
2005     }
2006     virtual void run() = 0;
2007 };
2008 
2009 class HandsetBrandN : public HandsetBrand
2010 {
2011 public:
2012     void run()
2013     {
2014         soft->run();
2015     }
2016 };
2017 
2018 class HandsetBrandM : public HandsetBrand
2019 {
2020 public:
2021     void run()
2022     {
2023         soft->run();
2024     }
2025 };
2026 
2027 int main()
2028 {
2029     HandsetBrand *hb;
2030     hb = new HandsetBrandM();
2031     
2032     hb->setHandsetSoft(new HandsetGame());
2033     hb->run();
2034     hb->setHandsetSoft(new HandsetAddressList());
2035     hb->run();
2036 
2037     return 0;
2038 }
2039 #endif
2040 
2041 #include <iostream>
2042 #include <string>
2043 #include <list>
2044 
2045 using namespace std;
2046 
2047 class Barbecuer
2048 {
2049 public:
2050     void bakeMutton()
2051     {
2052         cout << "烤羊肉串" << endl;
2053     }
2054     void bakeChickenWing()
2055     {
2056         cout << "烤鸡翅" << endl;
2057     }
2058 };
2059 
2060 class Command
2061 {
2062 protected:
2063     Barbecuer *receiver;
2064 public:
2065     Command(Barbecuer *receiver)
2066     {
2067         this->receiver = receiver;
2068     }
2069     virtual void executeCommand() = 0;
2070 };
2071 
2072 class BakeMuttonCommand : public Command
2073 {
2074 public:
2075     BakeMuttonCommand(Barbecuer *receiver) : Command(receiver)
2076     {}
2077     void executeCommand()
2078     {
2079         receiver->bakeMutton();
2080     }
2081 };
2082 
2083 class BakeChikenWingCommand : public Command
2084 {
2085 public:
2086     BakeChikenWingCommand(Barbecuer *receiver) : Command(receiver)
2087     {}
2088     void executeCommand()
2089     {
2090         receiver->bakeChickenWing();
2091     }
2092 };
2093 
2094 class Waiter
2095 {
2096 private:
2097     Command *command;
2098 public:
2099     void setOrder(Command *command)
2100     {
2101         this->command = command;
2102     }
2103     void notify()
2104     {
2105         command->executeCommand();
2106     }
2107 };
2108 
2109 class Waiter2
2110 {
2111 private:
2112     list<Command*> orders;
2113 public:
2114     void setOrder(Command *command)
2115     {
2116         orders.push_back(command);
2117     }
2118     void cancelOrder(Command *command) 
2119     {}
2120     void notify()
2121     {
2122         list<Command*>::iterator iter = orders.begin();
2123         while (iter != orders.end())
2124         {
2125             (*iter)->executeCommand();
2126             iter++;
2127         }
2128     }
2129 };
2130 
2131 
2132 int main()
2133 {
2134     Barbecuer *boy = new Barbecuer();
2135     Command *bm1 = new BakeMuttonCommand(boy);
2136     Command *bm2 = new BakeMuttonCommand(boy);
2137     Command *bc1 = new BakeChikenWingCommand(boy);
2138     
2139     cout << "Waiter2:" << endl;
2140     Waiter2 *girl2 = new Waiter2();
2141 
2142     girl2->setOrder(bm1);
2143      girl2->setOrder(bc1);
2144      girl2->setOrder(bm2);
2145     
2146     girl2->notify();
2147     
2148     cout << "Waiter:" << endl;
2149     Waiter *girl = new Waiter();
2150 
2151     girl->setOrder(bm1);
2152     girl->notify();
2153 
2154     girl->setOrder(bm2);
2155     girl->notify();
2156 
2157     girl->setOrder(bc1);
2158     girl->notify();
2159 
2160     return 0;
2161 }
2162 //Result:
2163 /*
2164 Waiter2:
2165 烤羊肉串
2166 烤鸡翅
2167 烤羊肉串
2168 Waiter:
2169 烤羊肉串
2170 烤羊肉串
2171 烤鸡翅
2172 */