Is having only a single template specialisation useful?

Question

I would like to know what are the main differences between the following methods. Is there a case were one of the two would cause problems if std::to_string is defined?

include <string>
using namespace std;


enum class eColor
{
   Red
};

void to_string(eColor color)
{
}

template<typename C = eColor)
void to_string(C color)
{
}



int main()
{
   to_string(eColor::Red); // assume only one of the above is defined
   return 0;
}

Is there a case where one of the above should be preferred?

Your template will create a mess. See https://stackoverflow.com/questions/1452721/why-is-using-namespace-std-considered-bad-practice — juanchopanza, Sep 15 '17 at 09:44
I don't see much point for the templated version. But your example is oversimplified, you should show the implementation as well. — user0042, Sep 15 '17 at 09:45
@juanchopanza I would actually like to know if there is any valid reason. — Nick, Sep 15 '17 at 09:46
@user0042 The actual implementation just uses the enum as an index for a static array of C-string an returns a `const char*`. — Nick, Sep 15 '17 at 09:47
@juanchopanza the template isn't in the std namespace, so it won't make a mess at all. — UKMonkey, Sep 15 '17 at 10:25
@UKMonkey That's not what I meant. It could make a mess if the template hides a call to `std::to_string` that doesn't exactly match one of the overloads. — juanchopanza, Sep 15 '17 at 10:48

score 1 · Answer 1 · answered Sep 15 '17 at 10:30

Your function to_string(eColor color) is not really a template specialization because it misses template<> before definition. So the compiler treats it as a fully defined function, not a template to be generated with a concrete type. That means this function will always be used as long the compiler can match the argument list.

score 0 · Answer 2 · answered Sep 15 '17 at 10:19

Despite things like the unnecessary pollution of the name space by your using directive which is especially weird if you plan on using names like to_string:

Template functions automatically deduce their template argument. So the following would be absolutely valid:

int main(int argc, const char * argv[]) {
    to_string(eColor::Red);
    to_string("Hey");
    to_string(42);
    return 0;
}

So if you really plan to taylor your function for one dedicated type you are in for some really interesting error messages or even worse no error messages combined with unwanted behavior.

The function version will a least prevent some of the erroneous cases. (It will still accept the 42 though since there is an implicit conversion).

Is having only a single template specialisation useful?

2 Answers2