Why default argument cannot be specified for an explicit template specialization?

Question

The below code couldn't pass the compilation, what's the consideration for this compiler error?

template<class T> void f(T t) {};

template<> void f<char>(char c = 'a') {}

Error message: Default arguments are not allowed on an explicit specialization of a function template

Answer 1

I think that the rationale behind this error is due to the fact that the default arguments in the function template apply to its specialization as well and you are not allowed to define the default argument more than once in C++.

Consider the following:

#include <iostream>

template<class T> void f(T t = 'a') {}

template<> void f<char>(char c)
{
    std::cout << c << std::endl;
}

int main(int argc, char **argv)
{
    f<char>();
}

This will print a meaning that specialization is called with the default argument defined in the main template.

If you need a different default argument for each specialization you can use the approach illustrated below:

#include <iostream>

template<class T>
struct default_arg
{
    static T get() { return T(); }
};

template<class T> void f(T t = default_arg<T>::get()) {}

template<>
struct default_arg<char>
{
    static char get() { return 'a'; }
};

template<> void f<char>(char c)
{
    std::cout << c << std::endl;
}

int main(int argc, char **argv)
{
    f<char>();
}

Answer 2

C++98 §12.7/21 "Default function arguments shall not be specified in ... the explicit specialization of a function template".

Regarding rationale I think it has to do with a call always being resolved against the primary template. A call that leaves out an argument required by the primary template, couldn't be resolved wihtout changing the lookup rules.

Answer 3

The selection of which particular template instance to use is based on the type of the parameter provided. Thus the selection of the explicit specialisation is made by the provisioning of a char argument - it is only at that point that the default argument (as you've codified) would come into play (where it is redundant).

It only makes sense to provide default arguments on the template declaration itself. The disadvantage is that you have to specific the appropriate specialisation yourself (which removes some of the advantages in using a default argument in the first place).

To achieve the behaviour that (I believe) you want, use the following.

template<class T> void f(T t) {}

template<> void f<char>(char c) {}

void f() { f('a'); }