pointeur constant en tant qu'argument de constructeur

Question

Il s'agit d'un point impair. Notez que ceci est réduit le code d'exemple, et manque délibérément des destructeurs). J'utilise la classe Ptr de cet exemple dans un vecteur, comme un pointeur vers une classe dérivée.

Comme nous pouvons le voir, le Ptr prend un Base<>* comme argument de constructeur.

Malheureusement, je besoin d'un constructeur qui prend une base de const <> *, et je ne peux pas simplement faire ceci:

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

Toute idée comment je peux faire accepter cette classe un const Base<>* comme il est constructeur?

---

Edit:

Ok, s'avère que je peux résoudre ce problème en modifiant le code indépendant, donc il est un peu un non-problème maintenant =] m'a pris environ un jour pour le fixer si = [

Answer 1

Je pense que vous devez définir une classe distincte pour renvoyer les pointeurs vers const, car non seulement les arguments du constructeur, mais aussi les types de retour des opérateurs doivent être remplacés par des versions const. Si vous faites le ConstPtr un friend de Ptr, cela devrait fonctionner assez bien:

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

Pour construire des enveloppes de pointeurs premières, vous pouvez ajouter une fonction surchargée, plus ou moins comme ceci:

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

Votre classe Ptr a un membre de pointeur non const. Vous ne serez pas en mesure d'attribuer un const Base* sans certains lancers dangereux. Veux-tu çà? Essayez ceci:

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

selon votre exemple, vous devriez faire

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

ps: Je n'aime pas const_cast et dans des cas similaires, j'essaie d'éviter cela. Peut-être besoin de faire deux implémentation de Ptr pour les arguments const et non const.