设计模式C++ 笔记二 结构型模式

1、Bridge模式

用户需求发生变化，要两个算法实现功能，往常状态需要多添加一个类。Bridge将系统分成两个相对独立的部分，抽象部分和实现部分。抽象部分根据参数，运行时动态决定采用哪个子类的函数。这样再加入一个函数实现时，只需要修改实现部分，继承出一个子类，不需要修改抽象部分。

//--------------Abstraction.h -----------------
 
#ifndef _ABSTRACTION_H_ 
#define _ABSTRACTION_H_ 
 
class AbstractionImp; 
 
class Abstraction //抽象部分
{ 
public: 
  virtual ~Abstraction(); 
 
  virtual void Operation() = 0; 
 
protected: 
  Abstraction(); 
 
}; 
 
class RefinedAbstraction:public Abstraction 
{ 
public: 
  RefinedAbstraction(AbstractionImp* imp); 
  ~RefinedAbstraction(); 
  void Operation(){   _imp->Operation();  }
 
private: 
  AbstractionImp* _imp; 
}; 

//--------------------AbstractionImp.h ------------------------
#ifndef _ABSTRACTIONIMP_H_ 
#define _ABSTRACTIONIMP_H_ 

class AbstractionImp //实现部分

{ 
public: 
  virtual ~AbstractionImp(); 
  virtual void Operation() = 0; 
protected: 
  AbstractionImp(); 
}; 

class  ConcreteAbstractionImpA:public AbstractionImp 
{ 
public: 
  ConcreteAbstractionImpA(); 
  ~ConcreteAbstractionImpA(); 
  virtual void Operation(); 
}; 
class  ConcreteAbstractionImpB:public AbstractionImp 
{ 
public: 
  ConcreteAbstractionImpB(); 
  ~ConcreteAbstractionImpB(); 
  virtual void Operation(); 
}; 

//------------------------AbstractionImp.cpp ----------------------------------
#include "AbstractionImp.h" 
#include <iostream> 
using namespace std; 

void AbstractionImp::Operation() 
{ 
  cout<<"AbstractionImp....imp..."<<endl; 
} 
ConcreteAbstractionImpA::ConcreteAbstractionImpA() 
{ 
} 
ConcreteAbstractionImpA::~ConcreteAbstractionImpA() 
{ 
} 
void ConcreteAbstractionImpA::Operation() 
{ 
  cout<<"ConcreteAbstractionImpA...."<<endl; 
} 
ConcreteAbstractionImpB::ConcreteAbstractionImpB() 
{ 
} 
ConcreteAbstractionImpB::~ConcreteAbstractionImpB() 
{ 
} 
void ConcreteAbstractionImpB::Operation() 

{ 
  cout<<"ConcreteAbstractionImpB...."<<endl; 
} 

//------------------------------main.cpp ------------------------
 
#include "Abstraction.h" 
#include "AbstractionImp.h" 
 
#include <iostream> 
using namespace std; 
 
int main(int argc,char* argv[]) 
{ 
  AbstractionImp*  imp  =  new   ConcreteAbstractionImpA(); 
 
  Abstraction*  abs  =  new   RefinedAbstraction(imp); 
 
  abs->Operation(); 
   
  return 0; 
} 

2、Adapter模式

当两个类的接口不一致时，使用Adapter将其中一个的接口转化为另一个希望的接口

//---------------------------Adapter.h -----------------------------类模式，通过继承获得接口
#ifndef _ADAPTER_H_ 
#define _ADAPTER_H_ 
class Target 
{ 
public: 
  Target(); 
  virtual ~Target(); 
  virtual void Request(); 
}; 
class Adaptee 
{ 
public: 
  Adaptee(); 
  ~Adaptee(); 
  void SpecificRequest(); 
}; 
class Adapter:public Target,privateAdaptee 
{ 
public: 
  Adapter(); 
  ~Adapter(); 
  void Request();  { this->SpecificRequest(); }
}; 

//----------------------Adapter.h --------------------------组合的方式，获得接口
#ifndef _ADAPTER_H_ 
#define _ADAPTER_H_ 
class Target 
{ 
public: 
  Target(); 
  virtual ~Target(); 
  virtual void Request(); 
}; 
class Adaptee 
{ 
public: 
  Adaptee(); 
  ~Adaptee(); 
  void SpecificRequest(); 
}; 
class Adapter:public Target 
{ 
public: 
  Adapter(Adaptee* ade); {this->_ade = ade; }
  ~Adapter(); 
  void Request(); {_ade->SpecificRequest(); }
private: 
  Adaptee* _ade; 
}; 

int main(int argc,char* argv[]) 
{ 
  Adaptee* ade = new Adaptee; 
 
  Target* adt = new Adapter(ade); 
 
  adt->Request(); 
 
  return 0; 
} 

在 Adapter 模式的两种模式中，有一个很重要的概念就是接口继承和实现继承的区别和联系。

接口继承指的是通过继承，子类获得了父类的接口。

实现继承指的是通过继承子类获得了父类的实现（并不统共接口）。

在 C++中的 public 继承既是接口继承又是实现继承，因为子类在继承了父类后既可以对外提供父类中的接口操作，又可以获得父类的接口实现。当然我们可以通过一定的方式和技术模拟单独的接口继承和实现继承，例如我们可以通过 private 继承获得实现继承的效果（private 继承后，父类中的接口都变为 private，当然只能是实现继承了。），通过纯抽象基类模拟接口继承的效果，但是在 C++中 pure virtual function 也可以提供默认实现，因此这是不纯正的接口继承，但是在 Java 中我们可以 interface 来获得真正的接口继承了。 

3、Decorator

在设计和开发中，当需要对一个类添加操作时，往往使用继承来实现。但是继承带来了系统的复杂性，这时候可以使用Decorator。它不是通过继承，而是通过组合的方式实现。

//--------------------------Decorator.h ----------------------------
#ifndef _DECORATOR_H_ 
#define _DECORATOR_H_ 
class Component 
{ 
public: 
  virtual ~Component(); 
  virtual void    Operation(); 
protected: 
  Component(); 
}; 
class ConcreteComponent:public Component 
{ 
public: 
  ConcreteComponent(); 
  ~ConcreteComponent();  
  void    Operation(){    std::cout<<"ConcreteComponent operation..."<<std::endl; } 
}; 
class Decorator:public Component 
{ 
public: 
  Decorator(Component* com) {   this->_com = com; } 
  virtual ~Decorator(); 
  void    Operation(); {}
protected: 
  Component* _com; 
}; 
class ConcreteDecorator:public Decorator 
{ 
public: 
  ConcreteDecorator(Component* com):Decorator(com) {      } 
  ~ConcreteDecorator(); 
  void    Operation(); {   _com->Operation();  this->AddedBehavior();  } 
  void AddedBehavior() {    std::cout<<"ConcreteDecorator::AddedBehacior...."<<std::endl; } 
}; 

int main(int argc,char* argv[]) 
{ 
  Component*  com  =  new ConcreteComponent();

  Decorator*  dec  =  new  ConcreteDecorator(com); 

  dec->Operation(); 

}

5、Flyweight

当系统中存在太多对象时，会造成太多的存储开销，特别是这些对象有共同特征时，比如都是字母a，这个时候可以使用Flyweight模式。

Flyweight 模式中有一个类似 Factory 模式的对象构造工厂FlyweightFactory，当客户程序员（Client）需要一个对象时候就会向 FlyweightFactory 发出请求对象的消息 GetFlyweight（）消息，FlyweightFactory 拥有一个管理、存储对象的“仓库”（或者叫对象池，vector 实现），GetFlyweight（）消息会遍历对象池中的对象，如果已经存在则直接返回给 Client，否则创建一个新的对象返回给 Client。当然可能也有不想被共享的对象（例如结构图中的 UnshareConcreteFlyweight），但不在本模式的讲解范围，故在实
现中不给出

//----------Flyweight.h -----------------

class Flyweight 
{ 
public: 
  virtual ~Flyweight(); 
  virtual  void  Operation(const  string& extrinsicState); 
  string GetIntrinsicState(); 
 
protected: 
  Flyweight(string intrinsicState)   {  this->_intrinsicState = intrinsicState; } ; 
 
private: 
  string _intrinsicState; 

}; 
 
class ConcreteFlyweight:public Flyweight 
{ 
public: 
  ConcreteFlyweight(string intrinsicState)  :Flyweight(intrinsicState) {    cout<<"ConcreteFlyweight Build....."<<intrinsicState<<endl; }

  ~ConcreteFlyweight(); 
 
  void  Operation(const  string& extrinsicState);  {   cout<<"ConcreteFlyweight: 内 蕴["<<this->GetIntrinsicState()<<"]  外 蕴["<<extrinsicState<<"]"<<endl; 
} 

//------------------FlyweightFactory.h ------------------
#include "Flyweight.h" 
#include <string> 
#include <vector> 
using namespace std; 
 
class FlyweightFactory 
{ 
public: 
  FlyweightFactory(); 
  ~FlyweightFactory(); 
 
  Flyweight*  GetFlyweight(const  string& key)

{

     vector<Flyweight*>::iterator  it  = _fly.begin(); 
 
  for (; it != _fly.end();it++) 
  { 
    //找到了，就一起用，^_^ 
    if ((*it)->GetIntrinsicState() == key) 
    { 
      cout<<"already  created  by users...."<<endl; 
 
      return *it; 
    } 
  } 
 
  Flyweight*  fn  =  new ConcreteFlyweight(key); 
 
  _fly.push_back(fn); 
 
  return fn; 

}; 

private: 
  vector<Flyweight*> _fly; 
 
}; 

//----------------main.cpp --------------------
#include "Flyweight.h" 
#include "FlyweightFactory.h" 
#include <iostream> 
using namespace std; 
 
int main(int argc,char* argv[]) 
{ 
  FlyweightFactory*  fc  =  new FlyweightFactory(); 
 
  Flyweight*  fw1  = fc->GetFlyweight("hello"); 
  Flyweight*  fw2  = fc->GetFlyweight("world!"); 
 
  Flyweight*  fw3  = fc->GetFlyweight("hello"); 
 
  return 0; 
}