首页 > 代码库 > c++面向对象程序设计学习心得

c++面向对象程序设计学习心得

首先介绍几个写类间关系和设计模式的技术博文

http://www.360doc.com/content/14/0613/21/18117192_386381321.shtml

http://blog.csdn.net/wuzhekai1985/article/details/6675799

http://www.cppblog.com/ming81/archive/2010/11/23/134404.html

状态模式:允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。它有两种使用情况:(1)一个对象的行为取决于它的状态, 并且它必须在运行时刻根据状态改变它的行为。(2)一个操作中含有庞大的多分支的条件语句,且这些分支依赖于该对象的状态。本文的例子为第一种情况,以战争为例,假设一场战争需经历四个阶段:前期、中期、后期、结束。当战争处于不同的阶段,战争的行为是不一样的,也就说战争的行为取决于所处的阶段,而且随着时间的推进是动态变化的。下面给出相应的UML图

 

   实现的代码比较简单,给出War类和State类,War类中含State对象(指针形式)。

 1 class War;   2 class State    3 {   4 public:   5     virtual void Prophase() {}   6     virtual void Metaphase() {}   7     virtual void Anaphase() {}   8     virtual void End() {}   9     virtual void CurrentState(War *war) {}  10 };  11 //战争  12 class War  13 {  14 private:  15     State *m_state;  //目前状态  16     int m_days;      //战争持续时间  17 public:  18     War(State *state): m_state(state), m_days(0) {}  19     ~War() { delete m_state; }  20     int GetDays() { return m_days; }  21     void SetDays(int days) { m_days = days; }  22     void SetState(State *
View Code

  给出具体的状态类:

 1 [cpp] view plaincopyprint? 2 //战争结束   3 class EndState: public State   4 {   5 public:   6     void End(War *war) //结束阶段的具体行为   7     {   8         cout<<"战争结束"<<endl;   9     }  10     void CurrentState(War *war) { End(war); }  11 };  12 //后期  13 class AnaphaseState: public State  14 {  15 public:  16     void Anaphase(War *war) //后期的具体行为  17     {  18         if(war->GetDays() < 30)  19             cout<<""<<war->GetDays()<<"天:战争后期,双方拼死一搏"<<endl;  20         else  21         {  22             war->SetState(new EndState());  23             war->GetState();  24         }  25     }  26     void CurrentState(War *war) { Anaphase(war); }  27 };  28 //中期  29 class MetaphaseState: public State  30 {  31 public:  32     void Metaphase(War *war) //中期的具体行为  33     {  34         if(war->GetDays() < 20)  35             cout<<""<<war->GetDays()<<"天:战争中期,进入相持阶段,双发各有损耗"<<endl;  36         else  37         {  38             war->SetState(new AnaphaseState());  39             war->GetState();  40         }  41     }  42     void CurrentState(War *war) { Metaphase(war); }  43 };  44 //前期  45 class ProphaseState: public State  46 {  47 public:  48     void Prophase(War *war)  //前期的具体行为  49     {  50         if(war->GetDays() < 10)  51             cout<<""<<war->GetDays()<<"天:战争初期,双方你来我往,互相试探对方"<<endl;  52         else  53         {  54             war->SetState(new MetaphaseState());  55             war->GetState();  56         }  57     }  58     void CurrentState(War *war) { Prophase(war); }  59 };  
View Code

  使用方式:

 1 int main()   2 {   3     War *war = new War(new ProphaseState());   4     for(int i = 1; i < 40;i += 5)   5     {   6         war->SetDays(i);   7         war->GetState();   8     }   9     delete war;  10     return 0;  11 }  
View Code

  转:http://blog.csdn.net/wuzhekai1985/article/details/6660462

工厂模式属于创建型模式,大致可以分为三类,简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多,都是工厂模式。下面一个个介绍,首先介绍简单工厂模式,它的主要特点是需要在工厂类中做判断,从而创造相应的产品。当增加新的产品时,就需要修改工厂类。有点抽象,举个例子就明白了。有一家生产处理器核的厂家,它只有一个工厂,能够生产两种型号的处理器核。客户需要什么样的处理器核,一定要显示地告诉生产工厂。下面给出一种实现方案。

 1 enum CTYPE {COREA, COREB};    2 class SingleCore   3 {   4 public:   5     virtual void Show() = 0; 6 };   7 //单核A   8 class SingleCoreA: public SingleCore   9 {  10 public:  11     void Show() { cout<<"SingleCore A"<<endl; }  12 };  13 //单核B  14 class SingleCoreB: public SingleCore  15 {  16 public:  17     void Show() { cout<<"SingleCore B"<<endl; }  18 };  19 //唯一的工厂,可以生产两种型号的处理器核,在内部判断  20 class Factory  21 {  22 public:   23     SingleCore* CreateSingleCore(enum CTYPE ctype)  24     {  25         if(ctype == COREA) //工厂内部判断  26             return new SingleCoreA(); //生产核A  27         else if(ctype == COREB)  28             return new SingleCoreB(); //生产核B  29         else  30             return NULL;  31     }  32 };  
View Code

  这样设计的主要缺点之前也提到过,就是要增加新的核类型时,就需要修改工厂类。这就违反了开放封闭原则:软件实体(类、模块、函数)可以扩展,但是不可修改。于是,工厂方法模式出现了。所谓工厂方法模式,是指定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

       听起来很抽象,还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱,于是决定再开设一个工厂专门用来生产B型号的单核,而原来的工厂专门用来生产A型号的单核。这时,客户要做的是找好工厂,比如要A型号的核,就找A工厂要;否则找B工厂要,不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

 1 class SingleCore   2 {   3 public:   4     virtual void Show() = 0; 5 };   6 //单核A   7 class SingleCoreA: public SingleCore   8 {   9 public:  10     void Show() { cout<<"SingleCore A"<<endl; }  11 };  12 //单核B  13 class SingleCoreB: public SingleCore  14 {  15 public:  16     void Show() { cout<<"SingleCore B"<<endl; }  17 };  18 class Factory  19 {  20 public:  21     virtual SingleCore* CreateSingleCore() = 0;22 };  23 //生产A核的工厂  24 class FactoryA: public Factory  25 {  26 public:  27     SingleCoreA* CreateSingleCore() { return new SingleCoreA; }  28 };  29 //生产B核的工厂  30 class FactoryB: public Factory  31 {  32 public:  33     SingleCoreB* CreateSingleCore() { return new SingleCoreB; }  34 };  
View Code

 工厂方法模式也有缺点,每增加一种产品,就需要增加一个对象的工厂。如果这家公司发展迅速,推出了很多新的处理器核,那么就要开设相应的新工厂。在C++实现中,就是要定义一个个的工厂类。显然,相比简单工厂模式,工厂方法模式需要更多的类定义。

       既然有了简单工厂模式和工厂方法模式,为什么还要有抽象工厂模式呢?它到底有什么作用呢?还是举这个例子,这家公司的技术不断进步,不仅可以生产单核处理器,也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。具体这样应用,这家公司还是开设两个工厂,一个专门用来生产A型号的单核多核处理器,而另一个工厂专门用来生产B型号的单核多核处理器,下面给出实现的代码。

 1 //单核   2 class SingleCore    3 {   4 public:   5     virtual void Show() = 0; 6 };   7 class SingleCoreA: public SingleCore     8 {   9 public:  10     void Show() { cout<<"Single Core A"<<endl; }  11 };  12 class SingleCoreB :public SingleCore  13 {  14 public:  15     void Show() { cout<<"Single Core B"<<endl; }  16 };  17 //多核  18 class MultiCore    19 {  20 public:  21     virtual void Show() = 0;22 };  23 class MultiCoreA : public MultiCore    24 {  25 public:  26     void Show() { cout<<"Multi Core A"<<endl; }  27   28 };  29 class MultiCoreB : public MultiCore    30 {  31 public:  32     void Show() { cout<<"Multi Core B"<<endl; }  33 };  34 //工厂  35 class CoreFactory    36 {  37 public:  38     virtual SingleCore* CreateSingleCore() = 0;39     virtual MultiCore* CreateMultiCore() = 0;40 };  41 //工厂A,专门用来生产A型号的处理器  42 class FactoryA :public CoreFactory  43 {  44 public:  45     SingleCore* CreateSingleCore() { return new SingleCoreA(); }  46     MultiCore* CreateMultiCore() { return new MultiCoreA(); }  47 };  48 //工厂B,专门用来生产B型号的处理器  49 class FactoryB : public CoreFactory  50 {  51 public:  52     SingleCore* CreateSingleCore() { return new SingleCoreB(); }  53     MultiCore* CreateMultiCore() { return new MultiCoreB(); }  54 }; 
View Code