template rebinding vs. late template binding or how to call piggy backing a template in a type

Question

Often conceptually a template must be passed as a type argument and the compiler complains because this is not legal c++ - at least until and including c++11 (Update II: except see last example of non specialized template definition)

These concepts are often used and should have a name. See the code examples below if it is not clear what I mean.

My first thought was that this may also be called passing an incomplete type but this is not correct. Another user also states that he has no word for it and freely names it late binding of template arguments. I think his terminology visualizes the concept well.

My question is how do you call the idiom behind this or the involved templates properly?

UPDATE Kerrek suggests naming the idiom template rebinding. This name renders only a few google results. However I think it is a very good name too because the standard allocators call their related wrapped internal classes rebind.

In the following example you could configure if your database uses map or hashmap internally:

#include <map>
struct map_wrapper
{
    template<typename K, typename V>
    using type =  std::map<K,V>;
};
template<typename storage>
struct my_database
{
    typename storage::template type<int, int> x;
    typename storage::template type<int, double> y;
};
main ()
{
    my_database<map_wrapper> db;
    db.x[0] = 1;
    db.y[0] = 2.0;
}

Or similarly

#include <map>
#include <boost/mpl/apply.hpp>
template <typename storage>
struct my_database
{
    typename boost::mpl::apply<storage, int>::type x;
    typename boost::mpl::apply<storage, double>::type y;
};
int main ()
{
    my_database< std::map<int, boost::mpl::_1> > db;
    db.x[0] = 1;
    db.y[0] = 2.0;
}

Update II: To my embarrassment I did not know the following solution which is just passing a template as argument to a template instantiation. In this special case it is legal to pass a non-type.

#include <map>
#include <unordered_map>

template<template<typename...> class Storage>
struct my_database
{
    Storage <long,char> x;
    Storage <long,double> y;
};

int main ()
{
    my_database< std::map > db1;
    db1.x[0] = '1';
    db1.y[0] = 2.2;
    my_database< std::unordered_map > db2;
    db2.x[0] = '1';
    db2.y[0] = 2.2;
}

Examples of other ways to rebind or late bind template arguments are of course welcomed.

Answer 1

You've provided a template where a type is expected.

For what it's worth, GCC 4.8 gives a decent diagnostic:

template <typename> struct Foo;
template <typename> struct Bar;

int main()
{
    Foo<Bar> x;
}

Diagnostic:

In function ‘int main()’:
error: type/value mismatch at argument 1 in template parameter list for ‘template<class> struct Foo’
Foo<Bar> x;
          ^
error:   expected a type, got ‘Bar’

(GCC got a lot better since Clang started producing very nice error messages, so this may be recent; I imagine Clang would also give a useful error here.)

---

Concerning your updated question: The typical way to make a container adapter, or generally a class that needs a certain container which you want to be customizable, is to pass the entire container as a template parameter:

template <typename XContainer, typename YContainer>
struct Database
{
    XContainer xstorage;
    YContainer ystorage;
};

Database<std::map<int, double>, std::unordered_map<std::string, double>> db;
db.xstorage[1] = 2.5;
db.ystorage["foo"] = 4.5;

This is the most general solution since you can use any class that fits your needs, without requiring that class to have any particular structure.

As an alternative (which I do not recommend), if you want all your containers to be template specializations of the same template, you can pass the template in directly as a template parameer (a so-called template template parameter):

template <template <typename, typename, typename...> class CTmpl,
          typename XType,
          typename YType>
struct Database
{
    CTmpl<XType, double> x;
    CTmpl<YType, double> y;
};

Database<std::map, int, std::string> db;
// as above

This is a lot more restrictive: not only does your database now have to use the same data structure for everything, but the data structure also has to be given as a template with fixed first two parameters "key type" and "mapped type".