template-specialization

In 17.6.4.2.1/1 and 17.6.4.2.1/2 of the current draft standard restrictions are placed on specializations injected by users into namespace std . 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. I cannot find

Suppose I've declared: template <typename T> void foo(T& t); Now, what is the difference between template <> void foo<int>(int& t); and template void foo<int>(int& t); semantically? And do template-with-no-brackets and template-with-empty-brackets have other semantics in other contexts? Related to: How do I force a particular instance of a C++ template to instantiate? Mark B template <> void foo<int>(int& t); declares a specialization of the template, with potentially different body. template void foo<int>(int& t); causes an explicit instantiation of the template, but doesn't introduce a

Compiling a project with an older version of g++ (4.8.0, MinGW) I found that this code fails to compile: template<typename T> void foo() = delete; template<> void foo<int>(){} int main() { foo<int>(); return 0; } It seems that g++ doesn't even try to look for explicit specializations if it sees that the base case is deleted. mitalia@mitalia:~/scratch$ /opt/mingw32-dw2/bin/i686-w64-mingw32-g++ -std=c++11 buggy_deleted_template.cpp buggy_deleted_template.cpp: In function 'int main()': buggy_deleted_template.cpp:8:14: error: use of deleted function 'void foo() [with T = int]' foo<int>(); ^ buggy

Reading this question made me wonder: is there a technical reason for disallowing class templates overloads? By overloading, I mean having several templates with the same names, but different parameters, for instance template <typename T> struct Foo {}; template <typename T1, typename T2> struct Foo {}; template <unsigned int N> struct Foo {}; The compiler manages to handle overloaded functions and function templates, wouldn't it be possible to apply the same techniques (e.g. name mangling) to class templates? At first, I thought that perhaps that would cause some ambiguity issues when taking