2

我正在尝试创建一个类，该类将包含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.
    }
};
4

2 回答 2

1

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

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

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

请注意，在您的情况下，我认为使用insertwith会更好initializer_list：

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

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

于 2013-11-07T04:22:19.227 回答
1

另一种方法：

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 {}
};
于 2013-11-07T15:54:25.497 回答