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

概念

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

代码解析

1.shape 类：定义了一个基类 shape，包含一个纯虚拟函数 clone，用于克隆对象。
2.circle 和 square 类：这两个类都继承自 shape，并实现 clone 方法。
3.克隆对象：在 main 函数中创建 circle 的原对象，然后调用 clone 方法来产生一个新的克隆对象。

使用拷贝构造函数

另一种方式是利用拷贝构造函数实现克隆。这在不需要多态的情况下是一个简单的解决方案。

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