Re: explicit specialization of enclosing member function template
zade_news_cn99 schrieb:
I have code like below:
template<class ValueType, size_t DimN>
class TPoint
{
public:
TPoint()
{
this->assignZero<DimN - 1>();
}
template<size_t index> inline
void assignZero()
{
this->data[index] = pt_type_trait<ValueType>::ZERO;
this->assignZero<index - 1>();
}
template<> inline
void assignZero<0>()
{
this->data[0] = pt_type_trait<ValueType>::ZERO;
}
private:
ValueType data[DimN]
Here I miss a trailing semicolon.
};
it is passed in vs2005; but fail in GCC 3.2.3. The error message
is:'enclosing class templates are not explicitly specialized'.
GCC is right, VS2005 is wrong (Note: Even VS2005-SP1 is still
wrong to allow it).
The page 310 of <<ISO C++ Standard (ISO14882) 2003>> gives an example on
explicit specialization of enclosing class template but not enclosing
member
function template.
On page 310 there is no specialization, most probably you mean
page 282 of the document (I assume, you meant the 310th page of the
pdf). If you look carefully, you see that the only valid explicit
member
template specializations (in [temp.expl.spec]-14.7.3/17-19) are
those,
where the outer class template is also fully specialized. And the text
in paragraph 18 says that clearly:
"In an explicit specialization declaration for a member of a class
template
or a member template that appears in namespace scope, the member
template and some of its enclosing class templates may remain
unspecialized,
except that the declaration shall not explicitly specialize a class
member
template if its enclosing class templates are not explicitly
specialized as well."
TPoint::assignZero is an enclosing member function template, so does it
mean
C++ standard has restrictions on explicit specialization of enclosing
member
function template?
The standard has such restrictions, but there exists a workaround for
your problem. The trick is, that you only provide *one* member
function
template, which uses a tagging technique to distinguish the proper
implementation of two overloaded functions, see solution (1).
An alternative technique would be to replace the tagging trick by
partial
specialization of a class template which contains a static
implementation
function, see solution (2).
Other solutions without partial specialization exist, but they are
rather
similar to the provided examples.
(1)
template<class ValueType, size_t DimN>
class TPoint
{
// Note: Partial specialization of class member
// templates is allowed:
template <size_t index, bool = index == 0>
struct ZeroTag{};
template <size_t index>
struct ZeroTag<index, true>{};
template<size_t index>
void doAssignZero(ZeroTag<index, true>)
{
this->data[0] = pt_type_trait<ValueType>::ZERO;
}
template<size_t index>
void doAssignZero(ZeroTag<index, false>)
{
this->data[index] = pt_type_trait<ValueType>::ZERO;
this->doAssignZero(ZeroTag<index - 1>());
}
public:
TPoint()
{
this->assignZero<DimN - 1>();
}
template<size_t index>
void assignZero()
{
this->doAssignZero(ZeroTag<index>());
}
private:
ValueType data[DimN];
};
(2)
template<class ValueType, size_t DimN>
class TPoint
{
// Also uses partial implementation of two
// class templates:
template<size_t index, bool = index == 0>
struct Do {
static void assignZero(TPoint& that) {
that.data[index] = pt_type_trait<ValueType>::ZERO;
Do<index - 1>::assignZero(that);
}
};
template<size_t index>
struct Do<index, true> {
static void assignZero(TPoint& that) {
that.data[0] = pt_type_trait<ValueType>::ZERO;
}
};
public:
TPoint()
{
this->assignZero<DimN - 1>();
}
template<size_t index>
void assignZero()
{
Do<index>::assignZero(*this);
}
private:
ValueType data[DimN];
};
Greetings from Bremen,
Daniel Kr|gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]