原型模式（Prototype Pattern）

原型模式（Prototype Pattern）是一种创建型设计模式，它通过克隆现有对象来创建新对象，而无需通过实例化类并设置其属性。

概念

原型模式通过克隆已有对象来创建新的对象，避免了类创建者与类使用者之间的依赖关系，提供了一种更加灵活的对象创建方式。

思想

原型模式的核心思想是在原型对象的基础上进行克隆，而不是重新创建一个对象。通过克隆，原型模式可以避免子类化，使得对象的创建更加灵活。

角色

• 抽象原型（Abstract Prototype）：声明克隆方法，是所有具体原型类的共同接口。
• 具体原型（Concrete Prototype）：实现抽象原型的克隆方法，克隆自身以创建新的对象。
• 客户端（Client）：使用原型模式的客户端代码，通过克隆创建新对象。

优点

• 简化对象的创建过程，避免了类创建者与类使用者之间的依赖关系。
• 可以动态添加或删除原型，灵活性高。
• 可以避免子类化，提高性能。

缺点

• 需要为每个类都实现克隆方法，增加了类的复杂度。
• 克隆方法需要深复制或浅复制的考虑，可能会导致对象状态的不一致。

类图

@startuml
class AbstractPrototype {
    +Clone(): AbstractPrototype
}

class ConcretePrototypeA {
    +Clone(): AbstractPrototype
}

class ConcretePrototypeB {
    +Clone(): AbstractPrototype
}

class Client {
    -prototype: AbstractPrototype
    +SetPrototype(prototype: AbstractPrototype)
    +MakeClone(): AbstractPrototype
}

Client -- AbstractPrototype
Client ..> ConcretePrototypeA
Client ..> ConcretePrototypeB
@enduml

示例代码（C++）

#include <iostream>
#include <string>

// 抽象原型
class AbstractPrototype {
public:
    virtual AbstractPrototype* Clone() = 0;
    virtual void SetData(const std::string& data) = 0;
    virtual void PrintData() = 0;
};

// 具体原型A
class ConcretePrototypeA : public AbstractPrototype {
private:
    std::string data;

public:
    AbstractPrototype* Clone() {
        ConcretePrototypeA* clone = new ConcretePrototypeA();
        clone->SetData(this->data);
        return clone;
    }

    void SetData(const std::string& data) {
        this->data = data;
    }

    void PrintData() {
        std::cout << "ConcretePrototypeA: " << data << std::endl;
    }
};

// 具体原型B
class ConcretePrototypeB : public AbstractPrototype {
private:
    std::string data;

public:
    AbstractPrototype* Clone() {
        ConcretePrototypeB* clone = new ConcretePrototypeB();
        clone->SetData(this->data);
        return clone;
    }

    void SetData(const std::string& data) {
        this->data = data;
    }

    void PrintData() {
        std::cout << "ConcretePrototypeB: " << data << std::endl;
    }
};

// 客户端
class Client {
private:
    AbstractPrototype* prototype;

public:
    void SetPrototype(AbstractPrototype* prototype) {
        this->prototype = prototype;
    }

    AbstractPrototype* MakeClone() {
        return prototype->Clone();
    }
};

int main() {
    ConcretePrototypeA* originalA = new ConcretePrototypeA();
    originalA->SetData("Data A");

    ConcretePrototypeB* originalB = new ConcretePrototypeB();
    originalB->SetData("Data B");

    Client client;

    // 使用原型A创建新对象
    client.SetPrototype(originalA);
    AbstractPrototype* cloneA = client.MakeClone();
    cloneA->PrintData();

    // 使用原型B创建新对象
    client.SetPrototype(originalB);
    AbstractPrototype* cloneB = client.MakeClone();
    cloneB->PrintData();

    delete originalA;
    delete originalB;
    delete cloneA;
    delete cloneB;

    return 0;
}

示例代码描述： 示例代码中定义了抽象原型（AbstractPrototype）作为克隆方法的接口，具体原型A（ConcretePrototypeA）和具体原型B（ConcretePrototypeB）实现了克隆方法，并添加了自己的数据成员和打印方法。客户端（Client）通过设置原型并调用克隆方法来创建新的对象。

在示例代码中，创建了原型A和原型B的对象，并设置它们的数据。然后，通过客户端使用原型A和原型B分别创建了两个克隆对象，并打印了它们的数据。运行结果如下：

codeConcretePrototypeA: Data A
ConcretePrototypeB: Data B