C++ 克隆智能指针与抽象工厂

我需要获得一些抽象类型的新实例，我想到的两件事是抽象工厂和克隆智能指针。哪一个看起来更好？工厂方法似乎更通用，但过于冗长，尤其是在嵌套抽象对象时。克隆指针更紧凑，但看起来有点难看，因为我们需要创建一个“虚拟”对象作为模板来创建其他对象

class IObject {
public:
    virtual ~IObject() {}
};

class Foo: public IObject {
public:
    struct Config {};
    explicit Foo(const Config& config): config_(config) {}

private:
    Config config_;
};

摘要工厂：

class IObjectFactory {
public:
    virtual ~IObjectFactory() {}
    virtual std::unique_ptr<IObject> Create() const = 0;
};

class FooFactory: public IObjectFactory {
public:
    explicit FooFactory(const Foo::Config& config): config_(config) {}

    std::unique_ptr<IObject> Create() const {
        return std::unique_ptr<IObject>(new Foo(config_));
    }

private:
    Foo::Config config_;
};

void DoSomething(const std::shared_ptr<IObjectFactory>& factory) {
    std::vector<std::shared_ptr<IObject>> objects;
    for (int i = 0; i < 10; ++i) {
        objects.push_back(factory->Create());
    }
    // Do something with the created objects
}

int main() {
    auto factory = std::make_shared<FooFactory>(Foo::Config());
    DoSomething(factory);
}

类IObjectFactory{
公众：
虚拟~IObjectFactory（）{}
虚拟std:：unique_ptr Create（）const=0；
};
FooFactory类：公共IObjectFactory{
公众：
显式FooFactory（const Foo:：Config&Config）：配置（Config）{}
std:：unique_ptr Create（）常量{
返回std:：unique_ptr（新的Foo（配置））；
}
私人：
Foo:：Config\uux；
};
无效剂量测量（常数标准：：共享试验和工厂）{
向量对象；
对于（int i=0；i<10；++i）{
对象。向后推（工厂->创建（））；
}
//对创建的对象执行一些操作
}
int main（）{
auto factory=std:：make_shared（Foo:：Config（））；
DoSomething（工厂）；
}

克隆指针（）：

模板类克隆\u ptr；//深度克隆智能指针
无效剂量测量（常数克隆和对象）{
向量对象；
对于（int i=0；i<10；++i）{
对象。推回（对象）；
}
//对创建的对象执行一些操作
}
int main（）{
克隆ptr对象（新的Foo（Foo:：Config（））；
剂量测量（对象）；
}

更简单的方法是您没有提供选项。向基本对象添加虚拟克隆功能，并使用该功能克隆对象

我不太明白您提供的两种方法如何解决相同的问题。。。指针方法很复杂，要想正确使用它，智能指针必须执行魔术来跟踪内部存储的真实类型，以便能够克隆（将魔术想象为类型擦除）。如上所示的工厂要求您知道要克隆的类型

template <typename T> class clone_ptr; // deep cloning smart pointer

void DoSomething(const clone_ptr<IObject>& object) {
    std::vector<clone_ptr<IObject>> objects;
    for (int i = 0; i < 10; ++i) {
        objects.push_back(object);
    }
    // Do something with the created objects
}

int main() {
    clone_ptr<IObject> object(new Foo(Foo::Config()));
    DoSomething(object);
}