Builer模式
：将构造复杂对象的过程和组成对象的部件解耦。
组成：
1.抽象建造者角色
2.具体建造者角色
3.指导角色
4.产品角色
// 抽象建造者角色，它规范了所有媒体建造的步骤:
class AbstractBuiler{
private:
public:
AbstractBuiler(){};
virtual ~AbstractBuiler(){};

virtual void BuildPartA() = 0;
virtual void BuildPartB() = 0;
};
// Builder的派生类,实现BuilderPartA和BuilderPartB接口函数
class ConcteateBuiler:public AbstractBuiler{
ConcteateBuiler(){};
~ConcteateBuiler(){};

void BuildPartA()
{cout<<"ConcreateBuiler partA"<<endl;}
void buildPartB()
{cout<<"ConcteateBuilder partB"<<endl;}
};

class Director{
private:
Builder *m_pBuilder;
public:
Director(Builer *pBuilder)
: m_pBuilder(pBuilder)
{
}
~Director()
{
  if (NULL != m_pBuilder)
{
  delete m_pBuilder;
 m_pBuiler = NULL;
}
}

void Construct(){
  m_pBuiler->BuildPartA();
 m_pBuiler->BuildPartB();
}
};
// Builder的派生类,实现BuilderPartA和BuilderPartB接口函数
class ConcreateBuilder2
 : public AbstractBuiler
{
public:
 ConcreateBuilder2(){}
 virtual ~ConcreateBuilder2(){}

 virtual void BuilderPartA();
 virtual void BuilderPartB();
};

void main()
{
AbstractBuiler *abstractBuiler = new ConcreateBuilder2();
Director *director = new Director(abstractBuiler);
dirctor->Construct();
}
   建造模式可以使得产品内部的表象独立变化。在原来的工厂方法模式中，产品内部的表
象是由产品自身来决定的；而在建造模式中则是“外部化”为由建造者来负责。这样定义一个
新的具体建造者角色就可以改变产品的内部表象，符合“开闭原则”。
建造模式使得客户不需要知道太多产品内部的细节。它将复杂对象的组建和表示方式封
装在一个具体的建造角色中，而且由指导者来协调建造者角色来得到具体的产品实例。
每一个具体建造者角色是毫无关系的。
   建造模式可以对复杂产品的创建进行更加精细的控制。产品的组成是由指导者角色调用
具体建造者角色来逐步完成的，所以比起其它创建型模式能更好的反映产品的构造过程。
  建造模式在得到复杂产品的时候可能要引用多个不同的组件，在这一点上来看，建造模
式和抽象工厂模式是相似的。可以从以下两点来区分两者：创建模式着重于逐步将组件装配
成一个成品并向外提供成品，而抽象工厂模式着重于得到产品族中相关的多个产品对象；抽
象工厂模式的应用是受限于产品族的（具体参见《深入浅出工厂模式》），建造模式则不会。

单例模式又叫单态模式或者单件模式。保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式中的“单例”通常用来代表那些本质上
具有唯一性的系统组件（或者叫做资源）。比如文件系统、资源管理器等等。
实现的方法 将构造函数设为私有。
单例模式可分为有状态的和无状态的。有状态的单例对象一般也是可变的单例对象，多
个单态对象在一起就可以作为一个状态仓库一样向外提供服务。没有状态的单例对象也就是
不变单例对象，仅用做提供工具函数。
实现：
饿汉式：
class Singleton{
public:
static getInstance(){
 return m_Singleton;
}
private:
Singleton()
{
  m_Singleton = new Singleton();
}
Singleton* m_Singleton;
};
懒汉式:
Singleton::m_Singleton = Null;
class Singleton{
private:
static Singleton* m_Singleton;
SIngleton(){}
~Singleton()
{
  if(NULL ! = m_Singleton)
{
   delete m_Singleton;
}
}
public:
static Singleton* getInstance()
{
  if(NULL == m_Singleton)
 {
   m_Singleton = new Singleton();
 }
 return m_Singleton;
}
};

void main()
{
  Singleton *Singleton =  NULL;
  Singleton = getInstance();
}
 //单例模式到些为此，大家多指导批评

工厂模式(静态工厂模、工厂方法模式、抽象工厂模式) //代码用C++实现  部分是从大神们那里学来的

简单工厂模式 组成：1 工厂类角色 2抽象产品角色 3具体产品角色

//简单工厂模式
//抽象产品角色
class Car{
  virtual void drive() = 0;
};
//具体产品角色
class Benz:public Car{
 void drive(){
  cout<<"Driving Benz"<<endl;
}
};

class Bmw:public Car{
 void drive(){
 cout<<"Driving Bmw"<<endl;
}
};
.....

//工厂类角色
class Driver{
 static Car DriverCar(string s)
{
   if("Benz“ == s)
      return new Benz();
   if("Bmw" == s)
      return new Bmw();
 }
};

//具体产品角色
void main()
{
 Car *car = Driver.DriverCar("benz");
 car.drive();
 }


二、工厂方法模式
 工厂方法去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。
结构如下：
1 抽象工厂角色
2 具体工厂解难
3 抽象产品角色
4 具体产品角色
//抽象产品角色
//抽象产品角色
class Car{
public: 
virtual void drive() = 0;
};
//具体产品角色
class Benz:public Car{
public: 
void drive(){
  cout<<"Driving Benz"<<endl;
}
};
//抽象工厂角色
class  Driver{
public: 
virtual Car driveCar() = 0;
};
class BenzDriver:public Driver{
 private:
 public:
 Car driverCar(){
  return new Benz();
}
};

class BmwDriver:public Driver{
private:
public:
 Car driverCar(){
 return new Bmw();
}
};
//爆发户上场
void main()
{
  Driver *pDriver = new BenzDriver();
  Car car =  driver.driverCar();
  car.drive();
}

小结：也许在下面情况你可以考虑使用工厂方法模式：
1.当客户程序不需要知道要使用对象的创建过程。
2.客户程序使用的对象存在变动的可能，或者根本就不知道哪一个具体的对象。


三：抽象工厂模式
抽象工厂模式的用意为：给客户提供一个接口，可以创建多个族中的产品对象而且使用抽象工厂模式还要满足下列条件：
1）系统中有多个产品族，而系统一次只可能消费消费基中一族产品
2）同属于同一个产品族的产品以其使用。

1.抽象工厂角色
2.具体工厂角色
3.抽象产品角色
4.具体产品角色

//抽象基类
class AbstractProduct{
private:
public:
  virtual void fun() = 0;
};

class Product1:public AbstractProduct{
 void fun()
 {
  cout<<"product1"<<endl;
 }
};

class Product2:public AbstractProduct{
  void fun()
{ 
 cout<<"product2"<<endl;
}
};


class AbstractProductnew{
  virtual void fun1() = 0;
};
class Productnew1:public AbstractProductnew{
  void fun1()
{
 cout<<"cproductnew 1"<<endl;
}
};

class productnew2:public AbstractProductnew{
 void fun1()
{
 cout<<"productnew2"<<endl;
}
};
// 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
class AbstractFactory{
 public:
 virtual AsbtractProduct* CreateProduct() = 0;
 virtual AsbtractProductnew* Createproductnew() = 0;
};
   
// 派生类ConcreateFactory1,继承自AbstractFactory
// 生产产品A和产品B的第一种实现
class ConcreateFactory1:public AbstractFactory{
   AsbtractProduct* CreateProduct()
{
 cout<<"ConcrateFactory1"<<endl;
}
AsbtractProductnew* Createproductnew()
{
  cout<<"ConcteateFactory11"<<endl;
}
};

// 派生类ConcreateFactory2,继承自AbstractFactory
// 生产产品A和产品B的第2种实现
class ConcreateFactory1:public AbstractFactory{
   AsbtractProduct* CreateProduct()
{
 cout<<"ConcrateFactory2"<<endl;
}
AsbtractProductnew* Createproductnew()
{
  cout<<"ConcteateFactory22"<<endl;
}
};//代码只是伪代码 想运行需要自行修改