GoFデザインパターン - プロトタイプ編

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>

// Prototype.h
class Prototype {
public:
    virtual ~Prototype() = default;
    // 多態的に複製するために unique_ptr を返す
    virtual std::unique_ptr<Prototype> Clone() const = 0;
    virtual void Show() const = 0;
};

// ConcretePrototype.h
class ConcretePrototype : public Prototype {
public:
    ConcretePrototype(const std::string& name, int data)
        : name_(name), data_(new int(data)) {}

    // コピーコンストラクタ（深いコピー）
    ConcretePrototype(const ConcretePrototype& other)
        : name_(other.name_), data_(new int(*other.data_)) {}

    // Clone をオーバーライドしてコピーを返す
    std::unique_ptr<Prototype> Clone() const override {
        return std::make_unique<ConcretePrototype>(*this); // copy ctor を利用
    }

    void Show() const override {
        std::cout << "ConcretePrototype name=" << name_ << " data=" << *data_ << "\n";
    }

    ~ConcretePrototype() { delete data_; }

private:
    std::string name_;
    int* data_; // 単純化のため生ポインタ（実運用では smart pointer を推奨）
};

// PrototypeRegistry.h
class PrototypeRegistry {
public:
    void Register(const std::string& key, std::unique_ptr<Prototype> prototype) {
        registry_[key] = std::move(prototype);
    }

    std::unique_ptr<Prototype> Create(const std::string& key) const {
        auto it = registry_.find(key);
        if (it != registry_.end()) {
            return it->second->Clone();
        }
        return nullptr;
    }

private:
    std::unordered_map<std::string, std::unique_ptr<Prototype>> registry_;
};

// main.cpp
int main() {
    PrototypeRegistry registry;
    registry.Register("protoA", std::make_unique<ConcretePrototype>("A", 100));

    auto p1 = registry.Create("protoA");
    auto p2 = registry.Create("protoA");

    if (p1) p1->Show(); // ConcretePrototype name=A data=100
    if (p2) p2->Show(); // ConcretePrototype name=A data=100

    // p1, p2 は独立したオブジェクト（深いコピーが行われていれば data_ も別領域）
    return 0;
}

import copy
from abc import ABC, abstractmethod

class Prototype(ABC):
    @abstractmethod
    def clone(self):
        pass

class ConcretePrototype(Prototype):
    def __init__(self, name, data):
        self.name = name
        self.data = data  # mutable なオブジェクトを想定

    def clone(self):
        # shallow copy と deep copy を使い分けられる
        # return copy.copy(self)    # 浅いコピー
        return copy.deepcopy(self)  # 深いコピー

    def show(self):
        print(f"ConcretePrototype name={self.name} data={self.data}")

if __name__ == "__main__":
    proto = ConcretePrototype("pyA", {"k": [1,2,3]})
    c1 = proto.clone()
    c2 = proto.clone()
    c1.show()
    c2.show()