c++ - 可变参数模板类型解包到映射键

Question

我正在尝试创建一个类，该类将包含 type_index 键映射到作为模板参数传递的每种类型的指针。这将允许我在其声明中指定我的类将依赖的一系列类型。

我做了一些研究，但似乎只能找到解包参数的方法，而不是类型。我是这个主题的新手，如果能对术语进行任何澄清或对相关文本的引用，我将不胜感激。

template <typename T>
T* SomeFakeFactoryGetter() { return new T(); }

template <class... Injected>
class UtilityProvider
{
public:
    template <class U>
    U* GetUtility()
    {
        std::type_index idx = std::type_index(typeid(U));
        assert(_injectedClasses.find(idx) != _injectedClasses.end());
        return reinterpret_cast<U*>(_injectedClasses[idx]);
    }

    // **
    // How would I *unpack* all types for use as indices into my map?
    // ( I realise this function is not what I want.)
    template <Injected... C>
    void Unpack()
    {
        _injectedClasses[std::type_index(typeid(C))] = SomeFakeFactoryGetter<C>();
    }

private:
    typedef std::unordered_map<std::type_index, void*> InjectedMap;
    InjectedMap _injectedClasses;
};

class Bar{ public: void A() { printf("Hello bar"); } };
class Baz{ public: void B() { printf("Hello baz"); } };
class Nope {};

class Foo : public UtilityProvider<Bar, Baz>
{
public:
    Foo()
    {
        GetUtility<Bar>()->A();
        GetUtility<Nope>(); // Fail. User must specify which utilities this class     will use.
    }
};

Answer 1

我在这种情况下所做的是创建一个虚拟函数来扩展这些表达式，但它看起来很丑陋:

    template <int ... Dummies>
    void dummy(int&& ...){}

    template <class ... C>
    void Unpack()
    {
       dummy(((_injectedClasses[std::type_index(typeid(C))] = 
                 SomeFakeFactoryGetter<C>()), 0)...);
    }

请注意，在您的情况下，我认为将 insert 与 initializer_list 结合使用会更好:

    template <class ... C>
    void Unpack()
    {
      _injectedClasses.insert({std::make_pair(std::type_index(typeid(C)),
                                              SomeFakeFactoryGetter<C>())...});
    }

我找不到对此的直接提及，但我相信这两种方法之间存在重要区别，以防您不知道。 insert 不会覆盖现有的键值对，而 operator[] 会。如果这对您很重要，这会影响您应该使用哪种方法。