Re: implementation of reasonable type casting

From:

"Greg Herlihy" <greghe@pacbell.net>

Newsgroups:

comp.lang.c++.moderated

Date:

Tue, 23 Jan 2007 00:05:39 CST

Message-ID:

<1169529152.047572.152620@51g2000cwl.googlegroups.com>

dima.sorkin@gmail.com wrote:

  I thought of another way of conversion, rather bombastic,
but should work:
-- components:
    template class C_IMPL_BASE - has the contents of the class C from
the previous message.

template<typename A, typename B> class C :
   public C_IMPL_BASE<A,B> {
};

     // partial specialization for const case, but only the part needed
     // for conversion ctor, in order to not to duplicate code
template<typename A, typename B> class C<const A,const B> :
   public C_IMPL_BASE<const A,const B> {
    explicit C(C_IMPL_BASE<nonconstA,nonconstB> const &c)
};

This way the conversion from
C<A,B> to C<const A,const B> is explicit,
and C<X,Y> to C<X,Y> is by default copy ctors.

I think this idea is the one to implement. No boost, no mpl, no
template metaprogramming - just simple inheritance and straightfoward
partial specialization. As old-fashioned as this implementation may
appear, it solves the problem exactly as specified:

     // CBase replaces C

     template <class A, class B>
     class CBase
     {
     public:
         CBase() : pa(), pb() {}

         CBase( const CBase& c)
             : pa( c.pa ),
               pb( c.pb )
         {
         }

     private:
         A* pa;
         B* pb;
     };

     // General template for non-const types

     template <class A, class B>
     class C : public CBase< A, B>
     {
     public:
         typedef CBase<A, B> Base;

         C() : Base() {}

         C( const C& c)
             : Base( c )
         {
         }
     };

     // const type specialization

     template < class A, class B>
     class C< const A, const B >
         : public CBase< const A, const B >
     {
     public:
         typedef CBase<const A, const B> Base;

         C() : Base() {}

         C(const C& c )
             : Base(c)
         {
         }

         explicit
         C( const C<A, B>& c)
             : Base( (const Base&) c)
         {
         }
     };

     // test explicit conversion

     void f( const C<const int, const long>& c )
     {
     }

     int main()
     {
         C< int, long> c;
         C< const int, const long> k;

         f( k ); // OK
         f( c ); // Error - no implicit conversion
         f( C<const int, const long>(c)); // OK
     }

Greg

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]