Re: gcc specialization of template membert of template class
spamsink42@gmail.com wrote:
hello
i have a template class which stores a pointer which may need to be
recast as requested by client code. here's the relevant subset of the
code:
template <class PointerClass>
class StorePointer {
public:
template <class RequestedPointerClass>
boost::shared_ptr<RequestedPointerClass> getPointer() const {
return
boost::dynamic_pointer_cast<RequestedPointerClass>(storedPointer_);
}
private:
boost::shared_ptr<PointerClass> storedPointer_;
};
sometimes the class required by the client is exactly that stored in
which case i want to forego the cast. Visual Studio 2005 lets me do
that with the following specialization:
template <class PointerClass>
class StorePointer {
public:
template <class RequestedPointerClass>
boost::shared_ptr<RequestedPointerClass> getPointer() const {
return
boost::dynamic_pointer_cast<RequestedPointerClass>(storedPointer_);
}
template <>
boost::shared_ptr<PointerClass> getPointer<PointerClass>()
const {
return storedPointer_;
}
private:
boost::shared_ptr<PointerClass> storedPointer_;
};
when the above code is compiled under gcc 4.1.0, compilation fails with
the error message "explicit specialization in non-namespace scope".
It's not possible to define an explicit specialization of a class
member template of a class template unless the class template is itself
also an explicit specialization. The reason being is that the class
member template, getPointer in the example above, is not just one
function template, but actually represents an unlimited number of
individual function templates - one per each specialization of
StorePointer. Therefore in order for getPointer to be explicitly
specialized, it is first necessary to specify which getPointer member
template is the one being specialized.
In code like the above example, it often turns out that an ordinary
member function can solve the problem - and replace either the need for
an explicit specialization or even - as in this case - the need for a
class member template at all. After all, there appears to be little
reason for the getPointer method to accept a type parameter to indicate
what type getPointer should return. The client already supplies that
information when it assigns the result returned by getPointer().
Whatever type of object is assigned getPointer's result would in fact
be the same type that would be supplied to the getPointer member
templatet.
There are other advantages for having getPointer return the nominal
pointer type and having the client decide on whatever conversion (if
any) is needed. Depending on the circumstances, the client may choose
direct assignment (for a derived to base pointer conversion) or a
dynamic or static cast - the exact choice could well vary. A function
template can neither be flexible enough nor be smart enough to choose
the appropriate cast in every situation. On the contrary, by always
choosing the same type of cast for every case, a getPointer template
function would turn out either to be inefficient at times or incorrect
at times (and worsen the mistake by compiling successfully). So I would
recommend deferring to the client on the type of cast to apply to
getPointer's result and thereby also ensure that the compiler will
report an error whenever such a decision needs to be made.
Greg
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]