C++ 设计模式

单例模式：

单例模式作为一种策略，要求一个程序只能存在一个类的实例。单例模式可以保证一个类只会创建一个这个类的对象。

#include <iostream>

using namespace std;

class singleTon{
public:
static singleTon* instance(){
if(0==instance1){
instance1 = new singleTon();
}
return instance1;
}
protected:       //不允许进行实例化 可以设置为protected 或者是private
singleTon(){
cout<<"single..."<<endl;
}
~singleTon(){}
private:
static singleTon* instance1;
};
singleTon* singleTon::instance1 = 0;
int main()
{
singleTon* single = singleTon::instance();
singleTon* single1 = singleTon::instance();
return 0;
}

产生结果只有一个：


下面讲述另一种模式：

工厂模式

为了提高内聚和松耦合，一般都会抽象出一些类的公共接口形抽象基类或者接口，于此同时问题也就产生，很多的子类的都继承这个基类，我们必须知道子类的具体实现，这样会引起命名上的冲突，还有对以后的程序维护上是很困难的。还有另一个问题就是在父类中并不知道要具体实现哪一个子类。基于以上2点，引出了工厂模式。

工厂模式的特点：

1. 定义创建对象的接口，封装了对象的创建。

2. 使得实例化的具体操作延迟到了子类当中去了。

#include <iostream>
using namespace std;

class car{
public:
car(){}
virtual ~car(){}
virtual void info() = 0; //一个类的公共接口
};

class Ford:public car{
public:
Ford(){}
virtual ~Ford(){}
virtual void info(){
cout<<"Ford"<<endl;
}
};

class Toyota:public car{
public:
Toyota(){}
virtual ~Toyota(){}
virtual void info(){
cout<<"Toyota"<<endl;
}
};

class carFactory{
public:
carFactory():mNumcars(0){}
car* requestCar(){
mNumcars++;
return createCar();
}
int getNumCars() const{
return mNumcars;
}
protected:
virtual car* createCar() = 0; //一个工厂的抽象方法 等待不同的子工厂进行具体实例化（是到Ford还是到Toyota买车）
private:
int mNumcars;
};

class FordFactory:public carFactory{
protected:
virtual car* createCar(){   //具体的实现，来到了Ford工厂 才可以创建一个 Ford车。
return new Ford();
}
};

class ToyotaFactory:public carFactory{
protected:
virtual car* createCar(){   //实例化一个Toyota车
return new Toyota();
}
};

int main()
{
ToyotaFactory mycar;
car* xdcar = mycar.requestCar();    //父类指针指向了子类对象
xdcar->info();
delete xdcar;   //虚析构（父类指针派生类的对象）
FordFactory ford;
car* fordcar = ford.requestCar();
(*fordcar).info();
delete fordcar;    //虚析构（父类指针派生类的对象）
cout<<mycar.getNumCars()<<endl;   //向Ford厂商，Toyota厂商请求买车
cout<<ford.getNumCars()<<endl;
return 0;
}

测试结果：



对于以上的工厂模式，只是仅仅局限于一类类（Product是一类，有一个共同的基类），但要是为不同的类提供一个对象创建的接口，就需要引入抽象工厂模式。

抽象工厂模式：

抽象工厂模式，当有多个抽象角色的时候，使用的一种工厂模式，只是向客户端提供一种接口，使得客户端不必在指定具体产品情况下，创建多个产品族中的产品对象。

总之，要创建一组相关或是相互依赖的对象，无需指定他们的具体类。

代码如下：

#include <iostream>
using namespace std;

class AbstractProductA{
public:
AbstractProductA(){}
virtual ~AbstractProductA(){}
};
class ProductA1:public AbstractProductA{
public:
ProductA1(){
cout<<"create A1"<<endl;
}
~ProductA1(){}
};
class ProductA2:public AbstractProductA{
public:
ProductA2(){
cout<<"create A2"<<endl;
}
~ProductA2(){}
};
class AbstractProductB{
public:
AbstractProductB(){}
virtual ~AbstractProductB(){}
};
class ProductB1:public AbstractProductB{
public:
ProductB1(){
cout<<"create B1"<<endl;
}
~ProductB1(){}
};
class ProductB2:public AbstractProductB{
public:
ProductB2(){
cout<<"create B2"<<endl;
}
~ProductB2(){}
};
class AbstractFactory{
public:
AbstractFactory(){}
virtual ~AbstractFactory(){}
virtual AbstractProductA* createProductA()=0;
virtual AbstractProductB* createProductB()=0;
};
class concreteFactory1:public AbstractFactory{
public:
concreteFactory1(){}
~concreteFactory1(){}
AbstractProductA* createProductA(){
return new ProductA1();
}
AbstractProductB* createProductB(){
return new ProductB1();
}
};
class concreteFactory2:public AbstractFactory{
public:
concreteFactory2(){}
~concreteFactory2(){}
AbstractProductA* createProductA(){
return new ProductA2();
}
AbstractProductB* createProductB(){
return new ProductB2();
}
};
int main()
{
AbstractFactory* f1 = new concreteFactory1();
f1->createProductA();
f1->createProductB();
AbstractFactory* f2 = new concreteFactory2();
f2->createProductA();
f2->createProductB();
delete f1;
delete f2;
return 0;
}

Builder模式：

builder-pattern是将复杂对象的建造过程抽象出来，使用不同的方法可以构造出不同表现的对象。即要将对象的创建过程和对象的表示分开来，通过一步步的进行复杂的对象创建，在每一步的创建过程中输入不同的参数，使得经过相同的创建过程，但是最后得到的对象的展示是不同的。
一般使用情形：到构造过程必须允许被创建的对象有不同的表示。
builder模式逻辑图：



C++测试代码：

#include <iostream>
using namespace std;

class Product{
public:
Product(){
cout<<"generate a product"<<endl;
}
~Product(){}
};
class Builder{
public:
Builder(){}
virtual ~Builder(){}
virtual void BuilderA(const string& buildPara)=0;
virtual void BuilderB(const string& buildPara)=0;
virtual void BuilderC(const string& buildPara)=0;
virtual Product* getPro()=0;
};
class concreteBuilder:public Builder{
public:
concreteBuilder(){}
~concreteBuilder(){}
void BuilderA(const string& buildPara){
cout<<"stepA generate"<<"...."<<buildPara<<endl;
}
void BuilderB(const string& buildPara){
cout<<"stepB generate"<<"...."<<buildPara<<endl;
}
void BuilderC(const string& buildPara){
cout<<"stepC generate"<<"...."<<buildPara<<endl;
}
Product* getPro(){
BuilderA("stepA---");
BuilderB("stepB---");
BuilderC("stepC---");
return new Product();
}
};
class Director{
public:
Director(Builder* bld):build(bld){}
~Director(){
delete build;
}
void Construct(){
build->BuilderA("1");
build->BuilderB("2");
build->BuilderC("3");
}
protected:
Builder *build;
};
int main()
{
concreteBuilder *p = new concreteBuilder();
Director *d = new Director(p);
d->Construct();
p->getPro();

return 0;
}

原型模式：

原型模式提供了自我复制的功能，新对象的创建可以通过已有对象进行创建。

#include <iostream>
using namespace std;

class Prototype{
public:
Prototype(){
cout<<"this is prototype"<<endl;
}
virtual ~Prototype(){}
virtual Prototype* clone()=0;
};
class concretePrototype:public Prototype{
public:
concretePrototype(){}
concretePrototype(const concretePrototype& cp){
cout<<"return the index of concretePrototype"<<endl;
}
~concretePrototype(){}
Prototype* clone(){
return new concretePrototype(*this);
}
};
int main()
{
Prototype *p = new concretePrototype();
p->clone();
delete p;

return 0;
}