首先介绍几个写类间关系和设计模式的技术博文
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 };
c++面向对象程序设计学习心得