Overloading (not specializing) templates in std namespace

Question

This is very pedantic but in C++03 it was apparently non-conforming for a program to overload (not specialize) a template function in the std namespace: see mention of this here and long discussion on comp.lang.c++.moderated

i.e. this was ok:

namespace std
{
    template <>
    void swap (Foo & f, Foo & g)
    {
       // ...
    }
}

but this was not (if I understand correctly...):

namespace std
{
    template <typename T>
    void swap (TempateFoo<T> & f, TempateFoo<T> & g)
    {
       // ...
    }
}

Is this still true in C++11? Also, does this apply to template classes (like std::hash) too, or just template functions?

EDIT: also, is there any example of a standard library implementation such that the latter would break things in practice? And if not, is there a specific reason for disallowing overloads like in the second case above? (what could potentially break in theory?)

I think you cannot open `std` namespace for things other than specialization of templates. — Nawaz, Feb 27 '13 at 05:26
Remember that the answer to the question *"is there any example of standard library implementation such that the latter would break things in practice?"* might be NONE, but that doesn't mean that it will not break in future (if the Standard doesn't allow *such* addition to `std` namespace). — Nawaz, Feb 27 '13 at 05:34
*"does this apply to template classes too"* - How would you overload a class in the first place? — Christian Rau, Feb 27 '13 at 08:52

score 8 · Accepted Answer · answered Feb 27 '13 at 13:22

8

It is not possible to define a partial specialization of a function template in C++, so your second example defines an overload not a specialization. Since the standard only allows specializations to be added to namespace std, your overload is illegal.

Is this still true in C++11?

Yes.

Also, does this apply to template classes (like std::hash) too, or just template functions?

You can't overload class templates anyway, you can only overload functions. The same rules apply though, you can only specialize a class template if the specialization depends on a user-defined (meaning non-standard) type.

is there a specific reason for disallowing overloads like in the second case above? (what could potentially break in theory?)

As one example, the implementation might want to take the address of a function but if you've overloaded the function then taking the address could cause an ambiguity and fail to compile, meaning you've just broken valid code in the standard library.

answered Feb 27 '13 at 13:22

Jonathan Wakely

166,810
27
341
521

OK, great, that last part makes sense. – Stephen Lin Feb 27 '13 at 18:33
is partial specialization (of, eg. std::hash) with user-defined types ok, or just full specialization? – Stephen Lin Feb 27 '13 at 18:49
1

if the partial specialization depends on a user-defined type it's ok, e.g. `std::hash>` is OK because it depends on `MyTemplate` which is a user-defined type – Jonathan Wakely Feb 28 '13 at 12:15
Cool, is that last part (partial specializations in `std` on user-defined types being OK) new or was that true in C++03 as well? – Stephen Lin Mar 01 '13 at 01:24
"meaning non-standard" -- [I wish it was that clear](http://stackoverflow.com/q/23659222/1774667) – Yakk - Adam Nevraumont Jan 05 '15 at 21:05
@Yakk, it isn't properly specified (and that's a defect) but when the library clauses (17-30) say "user-defined" they mean non-standard, so `std::string` is not a user-defined type. When the language clauses say "user-defined" they mean not fundamental, so `std::string` _is_ user-defined. But in the context of this question it means a type not defined in the standard. – Jonathan Wakely Jan 06 '15 at 00:57

score 6 · Answer 2 · answered Feb 27 '13 at 05:31

n3376 17.6.4.2.1

The behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a namespace within namespace std unless otherwise specified. A program may add a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type and the specialization meets the standard library requirements for the original template and is not explicitly prohibited.

17.6.4.2.2

The behavior of a C++ program is undefined if it declares

— an explicit specialization of any member function of a standard library class template, or

— an explicit specialization of any member function template of a standard library class or class template, or

— an explicit or partial specialization of any member class template of a standard library class or class template.

A program may explicitly instantiate a template defined in the standard library only if the declaration depends on the name of a user-defined type and the instantiation meets the standard library requirements for the original template.

great, thanks! any clue why overloads aren't allowed, though? it's apparently come up in discussion enough so I have to imagine there's a reason for the restriction. — Stephen Lin, Feb 27 '13 at 05:37
I'm accepting this for now but if anyone can follow up with reasoning behind this restriction that would be great :) (I'm sure someone must have brought this up with the committee.) — Stephen Lin, Feb 27 '13 at 05:52
Adding an overload can cause existing *unrelated* calls to use that overload instead of whatever they were using before. Unrelated as in not mentioning your user-defined type at all. Specializations can't do that. — n. m. could be an AI, Feb 27 '13 at 06:15

Overloading (not specializing) templates in std namespace

2 Answers2

Linked

Related