Re: template member function specialisation of standard container functions
On 25/06/11 08:46, Daniel Kr?gler wrote:
Am 24.06.2011 21:01, schrieb cpp4ever:
OK folks, I think this is generally a very bad idea and would create my
own container class with a standard container member variable.
// I think this type of thing is a very bad idea
template<>
void std::vector<MyClass>::push_back(const MyClass&inp)
{
// specialised version
}
In fact, the standard library does not support this: [namespace.std] p2
is very strict in this regard:
"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."
You only may (partially) specialize a class template or specialize a
(free) function template of the Standard Library for a user-defined type
or user-defined type families.
The next question is, is this still a bad idea for your own template
container classes?
I don't think that a universally valid answer to this question is
possible. My personal experience is that I cannot remember to have this
done in production code ever. I probably need to see a particular
example to give any reasonable answer to this.
I'm not saying "never", but I expect it usually requires reasoning. My
theoretical arguments are:
1) If this specialization is a bug-fix, it is only a solution for a
small domain of types and generally inappropriate
2) If this specialization is provided to realize that the function gets
better performance I expect that this would not be the one and only one
function within the class template that requires this change. Further,
usually other member functions may currently rely on some specific
details of the current implementation.
HTH & Greetings from Bremen,
- Daniel Kr?gler
Hmmmm, I think the standard does not mean that member function
specialisation of a standard class cannot actually be done, rather that
to do so could invalidate the operation of the standard class making
it's behaviour undefined. Regardless of this, I agree with the standard
and hence it should not be attempted.
With regard to your own container template class, if a template class of
a type, (class SomeObject), requires a lot of it's member functions
specialised, (>60% perhaps), then surely it would be better to implement
a template class specialisation.
I'm thinking it would be a better idea to define those class template
member functions that often need specialisation as virtual, (as well as
the destructor), and then achieve the same result via inheritance and
overriding. In this case should the template class itself inherit a well
defined interface, (pure virtual base class)? This approach does appear
to be easier to implement/understand/extend than using class template
member function specialisations.
Thanks Daniel for your response, and like yourself I have never seen
this done for production code. This certainly suggests that although the
idea is possible, it is not a good solution for reasons I have given to
a better alternative solution idea in the previous paragraph.
All further thoughts and ideas on this are appreciated, even if it is a
somewhat esoteric part of the capability of C++.
Regards
cpp4ever
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]