Re: Explicit specialization of member class template

From:

Barry <dhb2000@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Sun, 30 Sep 2007 12:42:02 +0800

Message-ID:

<fdn9gn$2rp$1@aioe.org>

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