By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
449,409 Members | 1,148 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 449,409 IT Pros & Developers. It's quick & easy.

Explicit specialization of member class template

P: n/a
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) {
}
}
--
Thanks
Barry
Sep 30 '07 #1
Share this Question
Share on Google+
2 Replies


P: n/a
Barry wrote:
[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
specialization if the outter class is not templated. Right?

--
Thanks
Barry
Sep 30 '07 #2

P: n/a
Barry wrote:
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.

--
Thanks
Barry
Sep 30 '07 #3

This discussion thread is closed

Replies have been disabled for this discussion.