首页 > 代码库 > 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 *
给出具体的状态类:
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 };
使用方式:
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 }
转: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 };
这样设计的主要缺点之前也提到过,就是要增加新的核类型时,就需要修改工厂类。这就违反了开放封闭原则:软件实体(类、模块、函数)可以扩展,但是不可修改。于是,工厂方法模式出现了。所谓工厂方法模式,是指定义一个用于创建对象的接口,让子类决定实例化哪一个类。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 };
工厂方法模式也有缺点,每增加一种产品,就需要增加一个对象的工厂。如果这家公司发展迅速,推出了很多新的处理器核,那么就要开设相应的新工厂。在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 };