Question

Suppose I’m in a template and I want to know if a type parameter T is an instantiation of a particular template, e.g., std::shared_ptr:

template<typename T>
void f(T&& param)
{
    if (instantiation_of(T, std::shared_ptr)) ...   // if T is an instantiation of 
                                                    // std::shared_ptr...
  ...
}

More likely I’d want to do this kind of test as part of a std::enable_if test:

template<typename T>
std::enable_if<instantiation_of<T, std::shared_ptr>::type
f(T&& param) 
{
    ...
}

// other overloads of f for when T is not an instantiation of std::shared_ptr

Is there a way to do this? Note that the solution needs to work with all possible types and templates, including those in the standard library and in other libraries I cannot modify. My use of std::shared_ptr above is just an example of what I might want to do.

If this is possible, how would I write the test myself, i.e., implement instantiation_of?

Answer 1

A partial spec should be able to do it.

template <template <typename...> class X, typename T>
struct instantiation_of : std::false_type {};

template <template <typename...> class X, typename... Y>
struct instantiation_of<X, X<Y...>> : std::true_type {};

http://ideone.com/4n346

I actually had to look up the template template syntax, because I’ve basically never had cause to use it before.

Not sure how this interacts with templates like std::vector with additional defaulted arguments.