Un cast de SmartPointer qui pose probl�me

Bonjour,

Je suis en train de d�velopper une fonction sur une classe SmartPointer que j'ai d�ja d�velopper.

Cette fonction � pour but de retouner un smartPointer d'un autre Type mais partageant le meme pointeur que le premier. Je m'en sert pour le polymorphisme.

Ma fonction marche tr�s bien sauf que si je concerve certaines donn�es en private ca compile pas avec cet erreur :

Code:

---

1 2 3 4 5

../library/libutils/smartpointer.h:254: error: 'SDLWidget* SmartPointer<SDLWidget>::ref' is private ../library/libutils/smartpointer.h:139: error: within this context ../library/libutils/smartpointer.h:255: error: 'unsigned int* SmartPointer<SDLWidget>::refCount' is private ../library/libutils/smartpointer.h:140: error: within this context

---

voici ma fonction :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

template <class X> SmartPointer<X> Cast(SmartPointer<T> &_smartPointer, X* _dummy) { SmartPointer<X> newSmartPointer;   mModRef.Lock(); newSmartPointer.ref = (X*)_smartPointer.ref; newSmartPointer.refCount = _smartPointer.refCount; *refCount++; mModRef.Unlock();   return newSmartPointer; }

---

Aparemment le probleme c'est que dans ce cas les variables ref et refCount deviennent priv�e pour la meme classe � cause du template.

J'ai essayer de r�soudre mon probleme en ajoutant un :
friend class Smartpinter; (ce qui est bizard dans la classe smarpointer dailleur) mais ca marche pas...

En attendant je met tout en public mais j'aurais aim� trouver une solution plus propre � ce probleme...

Quelqu'un � une id�e ???

Merci

Amiti� et templates ne marchent pas toujours tr�s bien d'un compilo � l'autre.
Quelle syntaxe tu avais utilis� pour d�clarer ta fonction amie ?

Ensuite, C<X> et C<Y> ne sont pas les m�mes classes. Ce qui explique qu'�tre ami avec Cast<SmPtr>, ce n'est pas comme �tre ami avec Cast<SmPtr<U> >.

Tu as regard� chez boost pour voir comment ils avaient proc�d� ?

Partant du principe que le fonctionnement de base de tes 'smarts pointers' ne d�pendent pas du type du pointeur encapsul�, je te sugg�re de faire ce que l'on fait classiquement dans ce cas : cr�er une classe de base, non template, regroupant ces fonctionnalit�s.
C'est notamment le cas dans les impl�mentations classique des conteneurs dans la STL.
Cette classe de base commune � toutes tes instanciations de template te permettra de faire ce que tu souhaites.
L'exemple que je joins est loin d'�tre parfait. Il est juste l� pour illustrer

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

//-- HEADER class SmartBase { public: ~SmartBase();   protected: SmartBase(void * ptr); SmartBase(const SmartBase& other);   int * refCount_; void * ptr_; };   //-- SOURCE   SmartBase::SmartBase(void * ptr) : ptr_(ptr) { refCount_ = new int(); *refCount_ = 1; }   SmartBase::~SmartBase() { if (*refCount_ == 0) delete refCount_; }   SmartBase::SmartBase(const SmartBase& other) { ptr_ = other.ptr_; refCount_ = other.refCount_; ++(*refCount_); }

---

Cette classe de base est 'abstraite' au sens de la conception. Elle ne peut �tre directement instanci�e (d'o� l'ensemble des constructeurs d�clar� comme prot�g�).
Ensuite ta classe SmartPtr � proprement parler en h�rite :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

//-- HEADER template<typename T> class SmartPtr : public SmartBase { public:   typedef T value_type; typedef T * pointer;   SmartPtr(T* ptr); SmartPtr(const SmartPtr& other); template<typename U> SmartPtr(const SmartPtr<U>& other); // L'opérateur de CAST en question ~SmartPtr(); pointer ptr() const; };   //-- SOURCE   template<typename T> SmartPtr<T>::SmartPtr(T* ptr) : SmartBase(ptr) { }   template<typename T> SmartPtr<T>::~SmartPtr() { if (!--(*refCount_)) delete reinterpret_cast<T*>(ptr_); }   template<typename T> SmartPtr<T>::SmartPtr(const SmartPtr<T>& other) : SmartBase(other) { }   template<typename T> template<typename U> SmartPtr<T>::SmartPtr(const SmartPtr<U>& other) : SmartBase(other) { static_cast<typename SmartPtr<T>::pointer>(other.ptr()); }

---

Le static cast

Code:

---

static_cast<typename SmartPtr<T>::pointer>(other.ptr());

---

est un moyen de s'assurer que la construction d'un SmartPointer � partir d'un autre se fait uniquement uniquement si le smart pointer construit est d'un type plus g�n�rique. Si ce n'est pas le cas, la compilation �chouera.
Il existe d'autres moyens plus propre de s'en assurer, cf Modern C++ Desgin de Andrei Alexandrescu.

HTH

Nikel ca marche ! Merci !