我想基于另一个只能在运行时知道类型的对象在堆上创建一个新对象。

举个假设的例子，假设我们有一款游戏，用户可以选择一个角色，该角色可以是巫师、战士或治疗师。计算机会创建一个匹配的非玩家角色来对抗玩家。也就是说，如果玩家选择了一个武士，计算机会生成另一个武士实例。

我正在尝试使用多态性。说巫师、战士和治疗师都继承自“战斗类型”类

我想做的是类似伪代码的事情:

    combattype* player = new (chosen at runtimetype)();//player
    combattype* baseptr = new typeid(*player);   // computer - this doesn't work

我知道我可以使用类似

if(typeid(player).name(*player) == typeid.name(warrior)) { // make warrior}

但是如果有数百种类型，这会很快变得复杂。我觉得有更好的方法，但我无法从概念上提出它。

我正在尝试做与这个问题类似的事情，但在 C++ 中:Dynamically create an object of <Type> 感谢您的帮助。

最佳答案

这(如果我理解正确的话)被称为 ¹克隆。只需在基类中添加一个虚clone 成员函数即可。在每个具体的派生类中覆盖它。

核心功能示例:

class Base
{
private:
    // Whatever
public:
    virtual auto clone() const
        -> Base*
    { return new Base( *this ); }

    virtual ~Base() {}
};

class Derived_A
    : public Base
{
public:
    auto clone() const
        -> Derived_A*        // OK, covariant return type.
        override
    { return new Derived_A( *this ); }
};

#include <assert.h>
#include <typeinfo>
auto main()
    -> int
{
    Base const& o = Derived_A{};
    auto p = o.clone();
    assert( typeid( *p ) == typeid( Derived_A ) );
    delete p;       // ← Manual cleanup is a problem with basic cloning.
}

用返回 Derived_A* 的函数覆盖 clone 函数而不是一般的 Base* 是可以的，因为它是一个原始指针和结果类型是协变的(在更具体的类中更具体，即以与类特异性相同的方式变化)。它也可以很好地用于原始引用。但是 C++ 不直接支持类类型函数结果，包括智能指针作为 clone 函数结果。

正如评论所指出的，直接、简单克隆的一个问题是清理责任不明确。最好是自动化和有保证，但随后会遇到不支持协变智能指针的问题。令人高兴的是，协变可以“手动”实现，方法是使虚拟 clone 函数成为非public，并在每个类中提供特定于类的智能指针结果包装函数。

具有协变智能指针结果的克隆示例:

#include <memory>       // std::unique_ptr

class Base
{
private:
    // Whatever, and
    virtual auto virtual_clone() const
        -> Base*
    { return new Base( *this ); }

public:
    auto clone() const
    { return std::unique_ptr<Base>( virtual_clone() ); }

    virtual ~Base() {}
};

class Derived_A
    : public Base
{
private:
    auto virtual_clone() const
        -> Derived_A*        // OK, covariant return type.
        override
    { return new Derived_A( *this ); }

public:
    auto clone() const
    { return std::unique_ptr<Derived_A>( virtual_clone() ); }
};

#include <assert.h>
#include <typeinfo>
auto main()
    -> int
{
    Base const& o = Derived_A{};
    auto p = o.clone();
    assert( typeid( *p ) == typeid( Derived_A ) );
    // Automatic cleanup.
}

下面是一种在 Base 和 Derived_A 中自动生成克隆支持机制的方法，基于中间人继承的概念:

#include <memory>       // std::unique_ptr
#include <utility>      // std::forward

// Machinery:
template< class Derived_t >
class With_base_cloning_
{
private:
    auto virtual virtual_clone() const
        -> Derived_t*
    { return new Derived_t( *static_cast<Derived_t const*>( this ) ); }

public:
    auto clone() const
    { return std::unique_ptr<Derived_t>( virtual_clone() ); }

    virtual ~With_base_cloning_() {}
};

template< class Derived_t, class Base_t >
class With_cloning_
    : public Base_t
{
private:
    auto virtual_clone() const
        -> Base_t*          // Ungood type because Derived_t is incomplete here.
        override
    { return new Derived_t( *static_cast<Derived_t const*>( this ) ); }

public:
    auto clone() const
    { return std::unique_ptr<Derived_t>( static_cast<Derived_t*>( virtual_clone() ) ); }

    template< class... Args >
    With_cloning_( Args... args )
        : Base_t( std::forward<Args>( args )... )
    {}
};

你会像这样使用它:

// Usage example:

class My_base
    : public With_base_cloning_<My_base>
{};

class Derived_A
    : public With_cloning_<Derived_A, My_base>
{};

#include <assert.h>
#include <typeinfo>
auto main()
    -> int
{
    My_base const& o = Derived_A{};
    auto p = o.clone();
    assert( typeid( *p ) == typeid( Derived_A ) );
    // Automatic cleanup.
}

With_cloning_中(private)virtual_clone函数的返回类型不是直接想要的，不理想，因为此时派生类还没有完成实例化模板的位置，因此编译器尚不知道它是从模板实例化派生的。

此中间人继承解决方案的替代方案包括一个简单的代码生成宏和虚拟继承层次结构中的(复杂)支配。

<支持> ¹ clone 函数，在底部调用最派生类的复制构造函数，是 virtual constructor idiom 的一个特例。 .另一个特殊情况是 create 函数，它在底部调用最派生类的默认构造函数。

关于c++ - 如何从另一个实例的类型动态实例化一个新实例？ C++，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38363089/