为什么我不能返回对使用模板创建的派生 class 的 unique_ptr 的引用？

Question

我有一个基于此链接的编译时“插件”系统，我想保留插件的所有权，这些插件实际上是独一无二的——每种类型应该只有一个实例。

有一个注册商 class 拥有插件类型，并拥有该插件的 unique_ptr。

我想在请求时返回对插件的引用，以保持所有权清晰。

更完整的代码如下。 注意在插件的 header 中注册的#define。

另外，我在这里将代码中的 Renderer 重命名为 Plugin，所以如果我错过了任何随机 Render 引用是/曾经的。

工厂 class：

class PluginFactory
    {
    public:
        // Instance of Factory
        static PluginFactory& Instance();
        void Register(IPluginRegistrar *Registrar, std::string name);
        
        IPlugin& GetPlugin(std::string name);

    private:
        std::unordered_map<std::string, IPluginRegistrar *>_registry;
        // private constructor, prevent copying
        PluginFactory() : _registry() {};
        PluginFactory(PluginFactoryconst&) = delete;
        void operator=(PluginFactoryconst&) = delete;
    };
    
    PluginFactory& PluginFactory::Instance()
    {
        static PluginFactoryinstance;
        return instance;
    }
    void PluginFactory::Register(IPluginRegistrar *registrar, std::string name)
    {
        if (_registry.count(name))
            std::cout << name << " is already registered!\n";
        else
        {
            std::cout << "Registering " << name << "\n";
            _registry[name] = registrar;
        }
    }
    IPlugin& PluginFactory::GetPlugin(std::string name)
    {
        IPluginRegistrar* registrar = _registry.at(name);        
        return registrar->GetPlugin();
    }
    #define REGISTER_PLUGIN(CLASSNAME) \
    namespace { \
    static MyNamespace::PluginRegistrar<CLASSNAME>\
    _registrar( #CLASSNAME ); \
    };

插件库

    class IPlugin
    {
    public:
        IPlugin() { std::cout << "Constructing IPlugin class\n";  }
        virtual void DoThing(){ std::cout << "Here's the thing from an IPlugin!\n"; };
        
    };

插件派生

    class TestPlugin : public IPlugin
    {
    public:
        TestPlugin ();        
        virtual void DoThing() override;
    };
    REGISTER_RENDERER(TestPlugin)

    TestPlugin::TestPlugin () : IPlugin()
    {
        std::cout << "Constructing TestPlugin class\n";
    }

    void TestPlugin::DoThing()
    {
        std::cout << "Here's the thing from a TestPlugin!\n";
    }

注册商

 class IPluginRegistrar
    {
    public:
        virtual IPlugin& GetPlugin() = 0;
  
    };

 template <class T>
    class PluginRegistrar: public IPluginRegistrar
    {
    public:
        PluginRegistrar(std::string classname); // constructor registers plugin with a plugin factory
        IPlugin& GetPlugin(); // GetPlugin is called by the factory
    private:
        std::string _name;    
        std::unique_ptr<IPlugin> _ptr;
    };

    template <class T>
    PluginRegistrar<T>::PluginRegistrar(std::string classname) : _name(classname)
    {
        PluginFactory& factory = PluginFactory::Instance();        
        factory.Register(this, classname);
    }

template <class T>
    IPlugin &
    PluginRegistrar<T>::GetPlugin()
    {
        if (!_ptr)
            _ptr = std::make_unique<T>();
        return *_ptr;                    
    }
    

使用代码：

    auto& factory = PluginFactory::Instance();
    auto plugin= factory.GetPlugin("TestPlugin");
    => outputs confirm derived class constructed
    plugin.DoThing();
    => output of IPlugin.DoThing(), not TestPlugin.DoThing()

每次调用GetPlugin()时，此代码的原始版本都会返回一个新的unique_ptr<IPlugin> ，并且效果很好。 但是现在我已经将返回类型切换为IPlugin & ，当我在结果上调用虚拟 function 时，基础 class function 被调用，而不是派生的。

Answer 1

auto plugin= factory.GetPlugin("TestPlugin");

这会将结果复制到一个新的 object 中，这将是一个IPlugin （原始派生类型将被切片）。 您想改用参考：

auto& plugin= factory.GetPlugin("TestPlugin");

您可能想让IPlugin::DoThing()成为纯虚拟 function （即virtual void DoThing() = 0 ），这将

1. 强制派生类实现它
2. 防止您拥有IPlugin类型的 object ，即使您的原始代码无法编译