I thought g++ used to warn for this:
template <typename T>
class foo { };
template<> class foo<int> { };
template class foo<int>;
Where the error was something informative like "one may not explicitly
specialize and explicitly instantiate" blah blah blah
However, mainline currently does not do this.
>From 14.7
-5- No program shall explicitly instantiate any template more than once, both
explicitly instantiate and explicitly specialize a template, or specialize a
template more than once for a given set of template-arguments. An
implementation is not required to diagnose a violation of this rule.
So, this is not required by the standard. As a QoI issue, however, this would
be beneficial.
Here's why I wanted this: if one is doing API testing, and the API requires
explicit specializations, than one possible negative test is to explicitly
instantiate the required specialization and get an error.
Otherwise, I suppose another neg test is to redefine the specialization. This
is also not required to give an error, but current g++ does (redefinition
error).
Note also, no diagnostic for duplicate explicit instantiations:
template <typename T>
class foo { };
template class foo<int>;
template class foo<int>;
Either of these or all may be a warning regressions (if my mind is not playing
tricks on me.)
I have not tested with other compilers, or previous g++ versions.
Consistent behavior for all three cases would be appreciated.
--
Summary: accepts both explicit instantiation and explicit
specialization, duplicate explicit instantiations, etc.
Product: gcc
Version: 4.3.0
Status: UNCONFIRMED
Severity: normal
Priority: P3
Component: c++
AssignedTo: unassigned at gcc dot gnu dot org
ReportedBy: bkoz at gcc dot gnu dot org
GCC build triplet: i686-pc-linux-gnu
GCC host triplet: i686-pc-linux-gnu
GCC target triplet: i686-pc-linux-gnu
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30857
