How to write a C++ template that accepts every class and class template?

Question

Be forewarned: This question seems way more obvious than it actually is.

I'd like to write a template that can accept any concrete class or template class as a template parameter. This might seem useless because without knowing whether the passed in T is templated or not you won't know how to use it. The reason I want this is so that I can declare a general template with no definition, that users then specialize. Because users are specializing it, they always know about the type they're dealing with. But users can't specialize a template without it first being declared.

You could do this:

template<class T>
class myclass;

But that won't work if you pass in a templated T, for example myclass<std::vector> won't work. So then we try this:

template<class T>
class myclass;

template<template<class> T>
class myclass;

This might be the right track, but it won't work as is because class templates can't be overloaded. So let's switch it to function templates, which can be:

template<class T>
void myfunc();

template<template<class> T>
void myfunc();

Sweet, so we're done right? Well, there might be different numbers of parameters given to the template template parameter, so we'll need to take that into account too.

template<class T>
void myfunc();

template<template<class> T>
void myfunc();

template<template<class, class> T>
void myfunc();

template<template<class, class, class> T>
void myfunc();

// etc.

Ugly, but the Boost Preprocessor Library can generate this code for us (and in C++0x support for variadic templates will be added so this ugliness is only temporary). But we've still forgotten a case! What if one of T's parameters isn't a class, but a constant integer. Lets try to support that:

template<class T>
void myfunc();

template<template<class> T>
void myfunc();

template<template<class, class> T>
void myfunc();

template<template<class, class, class> T>
void myfunc();

// etc.

template<template<class> T>
void myfunc();

template<template<class, int> T>
void myfunc();

template<template<int, class> T>
void myfunc();

template<template<int, class, class> T>
void myfunc();

template<template<class, int, class> T>
void myfunc();

template<template<class, class, int> T>
void myfunc();

// etc.

Uh oh. Given that any constant type can get passed into a template, in any number, mixed with class parameters, KABLOOEY combinatorial explosion. Just to make things more difficult, what if any of T's parameters are themselves templates?

Answer 1

The solution is: use function overloading and not template specialization! Compile time will be better, constraints gone ...

Remember that any template is considered instantiated at the closest global scope after which they are used. This mean that this will work:

template <class T>
int f(const T& t)
{
  return g(t);
} 

int g(int a)
{
  return a+1;
}

int main()
{
   return f(5);
}

As you see, it works even though the function g is defined after f. This means that you can define whatever template you want that uses the function, as long as the user defines the function before it uses the template, you're fine, C++ will find it.

Remember also that template specialization doesn't exist for functions! If many functions with the same name exist, C++ will always expect overloading, not template specialization.

In short, the best solution is: just use the function as if it existed and expect the users to define the function before they use the template.

Answer 2

boost::mpl does something like this (here's their idea of binding an argument). However, you have to make a lot of assumptions to make it work, like using;

template <class T> foo { }; typedef foo< int_<4> > my_foo_4;

instead of

template <int T> foo { }; typedef foo<4> my_foo_4;

to not have to offer overloads for all int, char, bool, etc combination.

I can't think of anything that would be more effective than the boost::mpl approach, and in general, I would think any approach would suffer a lot of problems; a class template is NOT a type, and it can't really be wedged into the type system that way (boost::mpl treats it as a function to create new types; more generically, it is used to create a "MetaFunction"). I'm not even sure if variadic templates are going to effect template template parameters (interesting question though).

Answer 3

template <class T> class myclass;

template <> class myclass<int>{};
template <> class myclass<std::vector<int>>{};
template <> class myclass<std::vector<std::vector<int> > >{};

Is this what you want?