C++ 实现对象的克隆 (多种方法)

#include <iostream>  
#include <memory>  
class Shape {  
public:  
    virtual ~Shape() {}  
    virtual std::unique_ptr<Shape> clone() const = 0; // 虚拟克隆函数  
};  
class Circle : public Shape {  
public:  
    Circle() { std::cout << "Circle created\n"; }  
    Circle(const Circle&) { std::cout << "Circle copied\n"; }  
    std::unique_ptr<Shape> clone() const override {  
        return std::make_unique<Circle>(*this); // 使用拷贝构造函数  
    }  
};  
class Square : public Shape {  
public:  
    Square() { std::cout << "Square created\n"; }  
    Square(const Square&) { std::cout << "Square copied\n"; }  
    std::unique_ptr<Shape> clone() const override {  
        return std::make_unique<Square>(*this); // 使用拷贝构造函数  
    }  
};  
int main() {  
    std::unique_ptr<Shape> original = std::make_unique<Circle>(); // 创建原对象  
    std::unique_ptr<Shape> copy = original->clone(); // 克隆对象  
    return 0;  
}

#include <iostream>  
class MyClass {  
public:  
    MyClass(int value) : data(value) {}  
    // 拷贝构造函数  
    MyClass(const MyClass& other) : data(other.data) {  
        std::cout << "MyClass copied\n";  
    }  
    void show() const {  
        std::cout << "Value: " << data << std::endl;  
    }  
private:  
    int data;  
};  
int main() {  
    MyClass original(42); // 创建原对象  
    MyClass copy = original; // 克隆对象  
    original.show();  
    copy.show();  
    return 0;  
}

#include <iostream>  
#include <memory>  
#include <unordered_map>  
class Product {  
public:  
    virtual ~Product() {}  
    virtual std::unique_ptr<Product> clone() const = 0; // 克隆接口  
};  
class ConcreteProductA : public Product {  
public:  
    std::unique_ptr<Product> clone() const override {  
        return std::make_unique<ConcreteProductA>(*this);  
    }  
};  
class ConcreteProductB : public Product {  
public:  
    std::unique_ptr<Product> clone() const override {  
        return std::make_unique<ConcreteProductB>(*this);  
    }  
};  
// 工厂类  
class Factory {  
public:  
    void registerProduct(const std::string& name, std::unique_ptr<Product> prototype) {  
        prototypes[name] = std::move(prototype);  
    }  
    std::unique_ptr<Product> create(const std::string& name) {  
        return prototypes[name]->clone(); // 克隆  
    }  
private:  
    std::unordered_map<std::string, std::unique_ptr<Product>> prototypes; // 存储原型对象  
};  
int main() {  
    Factory factory;  
    factory.registerProduct("ProductA", std::make_unique<ConcreteProductA>());  
    factory.registerProduct("ProductB", std::make_unique<ConcreteProductB>());  
    auto productA = factory.create("ProductA"); // 克隆对象 A  
    auto productB = factory.create("ProductB"); // 克隆对象 B  
    return 0;  
}