[Template] Surcharge operateur

bonjour

J'ai un petit probleme dans un bout de code je vois cette ligne :

dans une class SharePtr :

Code:

---

1 2 3 4 5 6 7

template<class U> operator SharePtr<U>{ return(U*)ptr; }   template<class U> operator U*(){ return(U*)ptr; }

---

La class SharePtr a une variable ptr;

ce qui me pose problème c'est l'opérateur surchargé je pensais qu'il n'y avait que = + - * / etc ... mais la j'ai du mal. Auriez vous une explication et/ou un exemple simple
Merci

Tu est sur qu'il ne manques pas des () :

Code:

---

1 2 3

template<class U> operator SharePtr<U>(){ return(U*)ptr; }

---

???


Je penses (mais je ne suis pas sur) qu'il s'agit de l'opérateur de cast :

Code:

---

1 2	DerivatedPtr<int> obj; SharePtr<int> &ref = (SharePtr<int>) obj;

---

Ce sont des opérateurs de conversion implicite. Si tu définis un C::operator X, tu pourras affecter une instance de ta classe C à une variable de type X sans faire la moindre conversion explicite.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class C { public : operator int() {return x;}   private : int x; };   C c; int xx = c;

---

Dans ce contexte, ce sont des opérateurs qui permettent de convertir implicitement un pointeur intelligent vers un type compatible (SharePtr<Derivee> en Base*) ou vers un pointeur intelligent de type compatible (SharePtr<Derivee> en SharePtr<Base> par exemple).
Ici c'est pas très malin car il n'y a absolument aucune restriction à la conversion, je pourrais convertir un SharePtr<Citron> en Pomme*.

tu as raison j'ai oublié les parenthéses apres <U>, par contre ca me faisait pensait au constructeur de base sans paramètre dans les deux cas mais bon juste la tete que ca avait. Operateur de cast humhum cela reste un mystere et a quoi ca pourrait bien servir dans ce contexe vu que des parenthése (type*) suffirait

merci quand meme pour la reponse..

Cela s'appelle un opérateur de conversion. La syntaxe de déclaration est la suivante

Code:

---

1 2 3 4

class A { operator T(); }

---

où T est un type quelconque. Note que contrairement aux autres opérateurs, il ne faut pas indiquer de type de retour, le type de retour est celui indiqué après le mot clé "operator".

a oui la je commence a entrevoir un peu le bout du tunnel faut que je me plonge un peu plus dans le code pour voir mais ton exemple est tres claire merci

a oui merci pour vos réponses je pense avoir compris, juste des conversions implicites pour pointer sur la variable ptr avec un objet a la base style Shareptr<Queueitem> renvoi un pointeur de type Queueitem->ptr

Oui c'est presque ça.

Ce que tu décris, ça serait plus la surcharge de l'opérateur ->

Un exemple précis t'as été donné plus haut :

Code:

---

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

class C { public: void f() { printf("Hello world !"); } };   SharePtr<C> p;   // Sucharge de -> p->f();   // Surcharge de T() (conversion implicite) C c = p;   c.f();

---

Tu vois la différence entre les 2 surcharges ?