Hello,
Je ne comprend pas comment fonctionne la conversion implicite.
mon prof fait dans son code :
auto m = expandMantissa<2M+1>(mantissa);//de type Unsigned<DigitType,2M+1>
static auto tooLarge = Unsigned<DigitType, M + 1>(1) << digits + 1;
DigitType est un type générique définis plus haut.
Les deux objets sont de type Unsigned<T,size_t> avec des tailles size_t différentes.
Un peu plus loin dans son code, il fait if(m >= tooLarge), je veux avoir une conversion implicite ici avec le constructeur, afin que les opérateur de comparaison puissent fonctionner.
J’ai définis les operateur de comparaison, un constructeur pour passer de Unsigned<T,N> en Unsigned<T,M> Voici ce que j’ai dans ma classe Unsigned
//V2
template<typename T, size_t N >
class Unsigned {
...
public:
template <size_t M>
Unsigned(const Unsigned<T,M>& other) : Unsigned<T,N>() { /*code*/}
bool operator==(const Unsigned &rhs) const{/*code*/}
bool operator<(const Unsigned &rhs) const{/*code*/}
//les 4 autres op de comparaison
//autre fonction
};
De cette manière ça fonctionne, mais je ne suis pas satisfait avec tous les operateurs de comparaison en membre.
Initialement j’avais ma classe de la manière suivante ce que je trouvais beaucoup plus propre.
//V1
template<typename T, size_t N >
class Unsigned {
...
public:
template <size_t M>
Unsigned(const Unsigned<T,M>& other) : Unsigned<T,N>() { /*code*/}
friend bool operator==(const Unsigned &lhs, const Unsigned &rhs) {/*code*/}
friend bool operator<(const Unsigned &lhs, const Unsigned &rhs) {/*code*/}
//autre fonction
};
template<T,N>
bool operator>(const Unsigned &lhs, const Unsigned &rhs){ return rhs < lhs;}
//...autres operateur de cmp qui utilise < et ==
- Avec la V1, la conversion automatique n’est pas effectuée, je ne comprend pas pourquoi. Habituellement, je ne rend pas membre des fonctions qui n’ont pas besoins de l’être.
- J’ai aussi essayé avec tout les opérateurs en amis : friend, mais pas plus de succès.
- Si dans la V2 je n’indique pas que les méthodes sont constantes, la conversion auto n’est à nouveau pas appliquée.
Quels sont les règles pour que la conversion se passe automatiquement, quel organisation est la meilleur pour surcharger les opérateurs de comparaisons ? J’ai regardé par ici
[…] est une fonction libre et elle ne sera instanciée que si les arguments correspondent aux paramètres.
Mais ça n’explique pas le fait que le la disparition du const fasse disparaitre la conversion automatique ou je rate qqch ?
