const указатель как аргумент конструктора

Question

Это странный вариант. Обратите внимание, что это сокращает пример кода и упускает деструкторы сознательно).

template <class f, class g> class Ptr; 

class RealBase 
{ 
}; 

template <class a, class b, class c = Ptr<a,b> > 
class Base : public RealBase 
{ 
public: 
    Base(){}; 
}; 

template <class d, class e> 
class Derived : public Base <d,e> 
{ 
public: 
    Derived(){}; 
    void DerivedMethod(){}; 
}; 
typedef Derived<double,double> D_Derived; 

template <class f, class g> 
class Ptr 
{ 
public: 
    Ptr(){}; 
    Ptr(Base<f,g,Ptr<f,g> >* 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; 
}; 

Я использую класс Ptr из этого примера в векторе как указатель на класс Derived.

Как мы видим, Ptr принимает Base<>* как аргумент конструктора.

К сожалению, мне нужен конструктор, который принимает константный Base <> *, и я просто не могу это сделать:

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

Любые идеи, как я могу сделать этот класс принять const Base<>*, как это конструктор?

---

Edit:

Хорошо, получается, что я могу это исправить путем внесения изменений в несвязанный код, так что это немного не-проблема сейчас =] У меня ушел около дня, чтобы исправить это, хотя = [

Answer 1

Я думаю, вам нужно определить отдельный класс для привязки указателей к const, так как вместо константных версий должны быть изменены не только аргументы конструктора, но и возвращаемые типы операторов. Если вы сделаете ConstPtrfriend из Ptr, это должно работать довольно красиво:

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

Для построения оберток из сырых указателей можно добавить перегруженную функцию, более или менее, как это:

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) 
} 

Answer 2

В вашем классе Ptr есть указатель-указатель, не являющийся константой. Вы не сможете назначить const Base* без каких-либо небезопасных бросков. Вы хотите, чтобы? Попробуйте вместо этого:

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 3

по вашему примеру, вы должны сделать

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

пс: Я не люблю const_cast и в подобных случаях, я стараюсь, чтобы избежать этого. Возможно, нужно выполнить две реализации Ptr для аргументов const и non const.