Explicit specialization of member class template

[Barry]

The following code compiles with VC8
but fails to compiles with Comeau online,

[Error
"ComeauTest.c", line 7: error: explicit specialization is not allowed in the
current scope
template <>
^

"ComeauTest.c", line 10: error: explicit specialization is not allowed
in the
current scope
template <>
^
End-Error]


I locate the standard here:

[STD
14.7.3 Explicit specialization [temp.expl.spec]
An explicit specialization of any of the following:
¡ª function template
¡ª class template
¡ª member function of a class template
¡ª static data member of a class template
¡ª member class of a class template
¡ª member class template of a class template
¡ª member function template of a class template
can be declared by a declaration introduced by template<>

End-STD]

if I didn't get it wrong, we can have member class template explicit
specialization if the outter class is not templated. Right?


///////////////////////////////////////////

struct A
{
private:
template <class T>
struct HasConvertionTo;

template <>
struct HasConvertionTo<long> {};

template <>
struct HasConvertionTo<bool> {};

public:
template <class T>
operator T () const
{
return Convert(HasConvertionTo<T>()); // CT error trigger
}

private:
template <class T>
T Convert(HasConvertionTo<T>) const // dispatcher
{
return Convert(T());
}

long Convert(long) const
{
return 10;
}

bool Convert(bool) const
{
return true;
}
};

int main()
{
A a;

long l = a;

if (a) {
}
}

 

[Barry]

[STD
14.7.3 Explicit specialization [temp.expl.spec]
An explicit specialization of any of the following:
¡ª function template
¡ª class template
¡ª member function of a class template
¡ª static data member of a class template
¡ª member class of a class template
¡ª member class template of a class template
¡ª member function template of a class template
can be declared by a declaration introduced by template<>

End-STD]

if I didn't get it wrong, we can have member class template explicit

sorry, typo, can't

 

[Barry]

The following code compiles with VC8
but fails to compiles with Comeau online,

[Error
"ComeauTest.c", line 7: error: explicit specialization is not allowed in
the
current scope
template <>
^

"ComeauTest.c", line 10: error: explicit specialization is not allowed
in the
current scope
template <>
^
End-Error]


I locate the standard here:

[STD
14.7.3 Explicit specialization [temp.expl.spec]
An explicit specialization of any of the following:
¡ª function template
¡ª class template
¡ª member function of a class template
¡ª static data member of a class template
¡ª member class of a class template
¡ª member class template of a class template
¡ª member function template of a class template
can be declared by a declaration introduced by template<>

End-STD]

if I didn't get it wrong, we can have member class template explicit
specialization if the outter class is not templated. Right?


///////////////////////////////////////////

struct A
{
private:
template <class T>
struct HasConvertionTo;

template <>
struct HasConvertionTo<long> {};

template <>
struct HasConvertionTo<bool> {};

public:
template <class T>
operator T () const
{
return Convert(HasConvertionTo<T>()); // CT error trigger
}

private:
template <class T>
T Convert(HasConvertionTo<T>) const // dispatcher
{
return Convert(T());
}

long Convert(long) const
{
return 10;
}

bool Convert(bool) const
{
return true;
}
};

int main()
{
A a;

long l = a;

if (a) {
}
}

14.7.3 Explicit specialization

2.
An explicit specialization of a member function, member class or static
data member of a class template
shall be declared in the namespace of which the class template is a
member. Such a declaration may also
be a definition. If the declaration is not a definition, the
specialization may be defined later in the namespace
in which the explicit specialization was declared, or in a namespace
that encloses the one in which
the explicit specialization was declared.

So I think the code should be written in this way:

[Code --
struct A
{
private:
template <class T>
struct HasConvertionTo;

public:
template <class T>
operator T () const
{
return Convert(HasConvertionTo<T>()); // CT error trigger
}

private:
template <class T>
T Convert(HasConvertionTo<T>) const // dispatcher
{
return Convert(T());
}

long Convert(long) const
{
return 10;
}

bool Convert(bool) const
{
return true;
}
};

template <>
struct A::HasConvertionTo<long> {};

template <>
struct A::HasConvertionTo<bool> {};
-- End-Code]

Which Comeau accepts.