模板到C ++ 14中的模板映射

Question

I want to do a template to template map in C++14. A priori, it seems that the following code does the trick

template<class T>
struct KeyType {};

template<class T>
struct ValueType {
    T x;
};

template<template<class> class K>
struct Map;

template<>
struct Map<KeyType> {
    template<class T>
    using type = ValueType<T>;
};

ValueType<int> test{42};
Map<KeyType>::type<int> testM{42}; // Same as above

However, the following expression, when compiled with clang++ v3.8 , returns false.

template<template<class> class TemplateType>
struct NeedsTemplate;

std::is_same<
    NeedsTemplate<ValueType>,
    NeedsTemplate<Map<KeyType>::type>
>::value; // False

I understand why it is false: it has already been answered here . Basically, the standard assures that template instantiations of aliases should be recognize as the same, but says nothing about templates them-self. Hence, with g++ , std::is_same is true, and with clang++ , it is false.

My question is: how can I implement a template to template map that will satisfy the std::is_same requirement both with g++ and clang++? I'm willing to use macro as a last resort...

Answer 1

What you're asking for, in general, is equivalent of functional comparison which is equivalent to the halting problem, ie, not computable. However...

If you only want to do this for some specific, pre-defined templates, you can specialize them for a tag class and then you can use NeedsTemplate on the tag class. That is,

namespace Reflect {
    struct Reflect {};
}

template<class T>
struct KeyType {};

namespace Reflect {
    struct KeyType {};
}

template<>
struct KeyType<Reflect::Reflect> {
    using type = Reflect::KeyType;
};

... and then work with KeyType<Reflect::Reflect> , which is a type, instead of KeyType , which is a template. Note that you might still take KeyType (template) on the interface; you just call std::is_same<> on reflections. Also note, this requires you to write the reflection for each type - albeit that's trivial with macros. Also, you can't use Reflect::Reflect as a key type. (You could do this the other way, via traits, but then you're specializing in the traits' namespace, which is a bit tricky with multiple files.)

#define REFLECT_TEMPLATE(TEMPL) \
    namespace Reflect {                \
        struct TEMPL {};               \
    };                                 \
    template<>                         \
    struct TEMPL<Reflect::Reflect> {   \
        using type = Reflect::KeyType; \
    };

If I were you, I'd also add a const char* name() const to the reflected type...

Answer 2

Don't use templates as your metaprogramming primitives. Use types. Similar, avoid values.

template<template<class...>class Z>
struct ztemplate{
  template<class...Ts>
  using apply=Z<Ts...>;
};
template<class Z, class...Ts>
using apply=typename Z::template apply<Ts...>;
using zapply=ztemplate<apply>;

You never work with raw template s, just ztemplate s.

template<class T>
struct KeyType {};
using zKeyType=ztemplate<KeyType>;

C++ metaprogramming works much nicer with types. If you want restrictions on your types (like it must be a ztemplate ) write SFINAE or psuedo-concepts to enforce it.

As a bonus, a ztemplate is a value that defines a template. Which opens you up to hana-style metaprogramming.

This does mean you have to canonically wrap your template code, and strip out direct template and value parameters (replacing with ztemplate and integral constant respectively). But you end up with much more powerful metaprogramming.

Instead of X<Blah> do apply<zX, Blah> . In effect, apply becomes the only template you directly use.

Note apply<zapply, zX, Blah> and apply<zapply, zapply, zX, Blah> etc is the same as apply<zX, Blah> .