Discussion :

[juls64]

bonjour

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

dans une class SharePtr :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[mchk0123]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Laurent Gomila]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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*.

[juls64]

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..

[Sylvain Togni]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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".

[juls64]

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

[juls64]

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

[mchk0123]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?