检索从中实例化类型的模板

Question

How can I retrieve the template a type was originally instantiated from?

I'd like to do the following:

struct Baz{};
struct Bar{};

template <typename T>
struct Foo {};

using SomeType = Foo<Bar>;

template <typename T>
using Template = get_template<SomeType>::template type<T>;

static_assert(std::is_same<Foo<Baz>, Template<Baz>>::value, "");

I know I can achieve this through partial specialization, but this forces me to specialize get_template for every template I want to use it with:

template <typename T>
struct get_template;

template <typename T>
struct get_template<Foo<T>>
{
    template <typename X>
    using type = Foo<X>;
};

live example

Is there a way around this limitation?

Answer 1

You could do something like that, using a template template parameter (should work for templates with any number of type arguments):

template <typename T>
  struct get_template;

template <template <class...> class Y, typename... Args>
  struct get_template<Y<Args...>> {
    template <typename... Others>
    using type = Y<Others...>;
  };

Then to get the template:

template <typename T>
using Template = typename get_template<SomeType>::type<T>;

As mentioned by @Yakk in the comment, the above only works for template that only have type arguments. You can specialize for template with specific pattern of type and non-type arguments, eg:

// Note: You need the first size_t to avoid ambiguity with the first specialization
template <template <class, size_t, size_t...> class Y, typename A, size_t... Sizes>
  struct get_template<Y<A, Sizes...>> {
    template <class U, size_t... OSizes>
    using type = Y<U, OSizes...>;
  };

...but you will not be able to specialize it for arbitrary templates.

---

DEMO (with Foo and std::pair ):

#include <type_traits>
#include <map>

struct Bar{};

template <typename T>
struct Foo {};

using SomeType = Foo<Bar>;

template <typename T>
  struct get_template;

template <template <class...> class Y, typename... Args>
  struct get_template<Y<Args...>> {
    template <typename... Others>
    using type = Y<Others...>;
  };

template <typename T>
using Template = typename get_template<SomeType>::type<T>;

static_assert(std::is_same<SomeType, Template<Bar>>::value, "");
static_assert(std::is_same<Foo<int>, Template<int>>::value, "");

using PairIntInt = std::pair<int, int>;
using PairIntDouble = std::pair<int, double>;

template <typename U1, typename U2>
using HopeItIsPair = 
  typename get_template<PairIntDouble>::type<U1, U2>;

static_assert(std::is_same<PairIntDouble, HopeItIsPair<int, double>>::value, "");
static_assert(std::is_same<PairIntInt, HopeItIsPair<int, int>>::value, "");

Answer 2

Not sure I got the question. Would this work?

#include<type_traits>
#include<utility>

template<typename V, template<typename> class T, typename U>
auto get_template(T<U>) { return T<V>{}; }

struct Baz{};
struct Bar{};

template <typename T>
struct Foo {};

using SomeType = Foo<Bar>;

template <typename T>
using Template = decltype(get_template<T>(SomeType{}));

int main() {
    static_assert(std::is_same<Foo<Baz>, Template<Baz>>::value, "");
}

You can generalize even more ( SomeType could be a template parameter of Template , as an example), but it gives an idea of what the way is.