Discussion :

[loicounet]

Bonjour,

Si on définit une classe

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class nouveau_type
{
  private:
      int m_valeur;
  public:
   nouveau_type& operator=(nouveau_type const &val)
  {
    this->m_valeur=val;
    return(*this);
  }
};

Avec la redéfinition de l'opérateur= comme précédent, il est donc possible d'effectuer l'opération suivante:

nouveau_type A = 7; //équivalent a A.m_valeur = 7;

J'en arrive donc a ma question===>
est il possible de faire l'inverse?

cad redéfinir l'opérateur= "standard"(agissant sur les types int/float/short/etc)...de telle sorte que le compilateur comprenne que

(int = nouveau_type) est équivalent à (int = nouveau_type.m_valeur)

(je pense à une redéfinition comme pour l'opérateur std::operator<< )

Merci d'avance de vos idées!

(Pour l'instant j'utilise une fonction "to_float" qui me retourne la valeur, mais ca complique la prog et la lisibilité, c'est quand meme plus joli un "=" transparent!)

[screetch]

oui tu peux regarder les operateurs de cast

Code :

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

1
2
3
4
5
6
7
class mon_type
{
  operator int() { return m_value; }
};
 
mon_type a = 7;
int x = a;

[loicounet]

bien merci screetch!

je savais pas que ca existait cette possibilité

ca marche avec tous les types!

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
    operator unsigned char() 
    { 
        return (this->m_pt_float.to_float()); 
    }
 
    operator signed char() 
    { 
        return (this->m_pt_float.to_float()); 
    }
    operator unsigned short() 
    { 
        return (this->m_pt_float.to_float()); 
    }
    operator signed short() 
    { 
        return (this->m_pt_float.to_float()); 
    }
    operator unsigned long() 
    { 
        return (this->m_pt_float.to_float()); 
    }
    operator float() 
    { 
        return (this->m_pt_float.to_float()); 
    }
    operator int() 
    { 
        return (this->m_pt_float.to_float()); 
    }

[Davidbrcz]

Les conversions implicites, c'est dangereux, car tu peux te retrouver avec des valeurs bizarres sans svaoir d'où elle viennent.

[Jean-Marc.Bourguet]

Les conversions implicites, c'est dangereux

Dangereux, le mot est peut-être fort mais ça fini par poser des problèmes quand on ne restreint pas leur utilisation.

En passant, loicounet, tu abuses de this et les conversions implicites qui ne sont pas const, ça me semble avoir guère de sens.

[Davidbrcz]

On me le dit tout le temps, n'y va pas à la hache. C'est vrai je prend la bombe A.

Disons que les conversion implicites, si c'est mal gérées , ca te fout un bordel pas possible, la plus part du temps, pour un service rendu assez faible.