const pointer as a constructor argument

Answer 1

Your Ptr class has a non-const pointer member. You will not be able to assign a const Base* without some unsafe casts. Do you want that? Try this instead:

template <class f, class g>
class Ptr
{
   public:
    Ptr(){};
    Ptr(Base<f,g,Ptr<f,g> > const* a) { in = *a; }
    Base<f,g,Ptr<f,g> >* operator->()
    {
        return &in;
    };

    Base<f,g,Ptr<f,g> >& operator*()
    {
        return in;
    };

private:
    Base<f,g,Ptr<f,g> > in;
};

Answer 2

according your example you should do

Ptr( const Base< f,g, Ptr< f, g > >* a )
{
   in = const_cast< Base<f,g,Ptr<f,g> >* > ( a );
}

ps: I don't like const_cast and in similar cases I try to avoid this. Maybe need do two implementation of Ptr for const and non const arguments.

Answer 3

I think you need to define a separate class to wrap pointers to const, since not only the arguments of the constructor, but also the return types of the operators should be changed to const versions. If you make the ConstPtr a friend of Ptr, this should work out quite nicely:

template<...>
class ConstPtr {
  const Base<...> *in;
  ConstPtr(Base<...>* a) { in = a; }
  ConstPtr(const Base<...>* a) { in = a; }
  ConstPtr(const Ptr<...> &a) { in = a.in; }
  ...
};

To construct wrappers from raw pointers you could add an overloaded function, more or less like this:

template<..., class P>
P make_ptr(Base<...> *t);

template<...>
Ptr<...> make_ptr< ..., Ptr<...> >(Base<...> *t) {
  return Ptr(t);
}

template<...>
ConstPtr<...> make_ptr< ..., ConstPtr<...> >(const Base<...> *t) {
  return ConstPtr(t)
}