c++ template function specialization - wrong number of template arguments?

Question

Okay, so I'm just learning about templates. Anyways, I'm probably (most definitely) doing something wrong, but here's the problem:

My first template function is declared like this:

template<typename T>
std::ostream& printFormatted(T const& container, std::ostream& os = std::cout) {
    //...
}

Then I'm supposed to implement a specialized case for maps, so this is what I tried to do:

template<>
std::ostream& printFormatted<std::map<typename key, typename value>>(std::map<typename key, typename value> const& container, std::ostream& os = std::cout) {
    //...
}

I might be making a mistake with my key/value variables, not sure, but regardless, when trying to compile I get the error message:

error: wrong number of template arguments (1, should be 4)
error: provided for ‘template<class _Key, class _Tp, class _Compare, class _Allocator> class std::__debug::map’

Clearly there's something I don't understand about templates or maps? Someone please help?

Answer 1

Assuming your uses of key and value are meant to be placeholers, you cannot declare template parameters inline with the keyword typename . That is to say, Foo<typename T> is always invalid -- but not to be mistaken with Foo<typename T::bar> which is different altogether. The syntax for specialization looks like:

// Declare template parameters up front
template<typename Key, typename Value>
std::ostream&
printFormatted<std::map<Key, Value> >(std::map<Key, Value> const& container, std::ostream& os = std::cout);

but that wouldn't work because it's a partial specialization and those are not allowed for function templates. Use overloading instead:

template<typename Key, typename Value>
std::ostream&
printFormatted(std::map<Key, Value> const& container, std::ostream& os = std::cout);

This overload will be preferred over the more general template.

Answer 2

What you're doing is not full specialization, but partial specialization, since you still have a template, only a more specialized one. However, you cannot partially specialize functions, so instead, we just provide a new overload. For std::map , you need four template parameters (as the error message helpfully tells you):

template <typename K, typename V, typename Comp, typename Alloc>
std::ostream & printFormatted(const std::map<K,V,Comp,Alloc> & m,
                              std::ostream & o = std::cout)
{
  // ...
}

Answer 3

This answer is not relevant to C++11

If you're using a pre-c++11 compiler, you can't use >> when closing nested templates. You need a space between the > s.

C++ sees >> as a different token than > , and the compiler doesn't use it to close templates. You need a space so the compiler sees a > followed by a > .

The following is more likely to work:

template<>
std::ostream& printFormatted<std::map<typename key, typename value> >(std::map<typename         key, typename value> const& container, std::ostream& os = std::cout) {
    //...
}