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[]会覆盖现有的键值对。如果这对您很重要，这可能会影响您应该使用哪种方法。

Answer 2

另一种方法：

template <typename ... C> struct Unpacker;

template <typename Tail, typename ... Queue>
struct Unpacker<Tail, Queue...>
{
    void operator () (InjectedMap& injectedClasses) const
    {
        _injectedClasses[std::type_index(typeid(Tail))] = SomeFakeFactoryGetter<Tail>();
        Unpacker<Queue...>()(injectedClasses);
    }
};

template <>
struct Unpacker<>
{
    void operator () (InjectedMap& injectedClasses) const {}
};

Variadic模板类型解压缩到地图键

2 个答案: