设计模式之原型模式Prototype的C++实现

1、原型模式提出

在软件功能设计中，经常面临着“某些结构复杂的对象”的创建工作，且创建的对象想拥有其他对象在某一刻的状态，则可以使用原型模型。原型模型是通过拷贝构造函数来创建对象，并且该对象拥有其他对象在某一刻的状态。

2、需求描述

设计产品A，B，这个产品有重量和单价，输出产品的价格。

3、原型模式代码实现

#include <iostream>
namespace factModel{
class AbsProduct{
public:
    AbsProduct(int kg,int price):m_kg(kg),m_price(price){};
    virtual void salePrice()=0;
    virtual AbsProduct* clone()=0;
    virtual ~AbsProduct()=default;
protected:
    int m_kg;
    int m_price;
};
class ProductA:public AbsProduct
{
public:
    ProductA(int kg,int price):AbsProduct(kg,price){};
    ProductA(const ProductA& org):AbsProduct(org.m_kg,org.m_price){
        this->m_kg = org.m_kg;
        this->m_price = org.m_kg;
    };

    virtual AbsProduct* clone() override
    {
        return new ProductA(this->m_kg,this->m_price);
    };

    virtual void salePrice()override
    {
        std::cout << "ProductA Info "<< m_kg << "kg, price " << m_price << ", sale " << m_kg * m_price
                  <<"."<< std::endl;
    };
    ~ProductA()=default;
};

class ProductB:public AbsProduct
{
public:
    ProductB(int kg,int price):AbsProduct(kg,price){};

    ProductB(const ProductB& org):AbsProduct(org.m_kg,org.m_price){
        this->m_kg = org.m_kg;
        this->m_price = org.m_kg;
    };
    virtual AbsProduct* clone()override
    {
        return new ProductB(this->m_kg,this->m_price);
    };
    virtual void salePrice()override
    {
        std::cout << "ProductB Info "<< m_kg << "kg, price " << m_price << ", sale " << m_kg * m_price
                  <<"."<< std::endl;
    };
    ~ProductB()=default;
};

//有构造参数时，是需要的具体工厂的,因为设计模式一般将new隔离在其他的文件中。（否则使用时就需要AbsProduct *pA = new ProductA(2,8);)
class AbsFact{
public:
    AbsFact()=default;
    virtual ~AbsFact()=default;
    virtual AbsProduct* createProduct()=0;
};
class FactA:public AbsFact
{
public:
    FactA()=default;
    ~FactA()=default;

    virtual AbsProduct* createProduct()override
    {
        AbsProduct* tmp = new ProductA(2,8);
        return tmp;
    }
};

class Use
{
public:
    AbsProduct* product;
    void setFactory(AbsProduct* pf){product = pf;};    //或者在构造函数中添加初始化字段值
    void saleProducts()
    {
         product->salePrice();
    }
};
}

int main()
{
    //创建方式1：通过工厂方法模式隔离ProductA的new
    factModel::AbsFact* pFactA = new factModel::FactA();
    factModel::AbsProduct *pPdtA = pFactA->createProduct();
    factModel::AbsProduct* pCloneA = pPdtA->clone();

    factModel::Use objA;
    objA.setFactory(pCloneA);
    objA.saleProducts();

    //创建方式2：直接使用new ProductB的方式创建对象
    factModel::AbsProduct *pPdtB = new factModel::ProductB(3,12);
    factModel::AbsProduct* pCloneB = pPdtB->clone();

    factModel::Use objB;
    objB.setFactory(pCloneB);
    objB.saleProducts();


    delete pFactA;
    pFactA = nullptr;
    delete pPdtA;
    pPdtA = nullptr;
    delete pCloneA;
    pCloneA = nullptr;

    delete pPdtB;
    pPdtB = nullptr;
    delete pCloneB;
    pCloneB = nullptr;
    return 0;
}

运行结果如下：

 上面代码main函数中的创建方式根据实际情况选择，如果想隔离new，则使用方式1。原型模式的优点是将创建对象（该新创建的对象具有其他对象的状态，但与其他对象的地址区域是相互独立的）变得比较简洁。