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;
}