Opérateurs de changement de type

Le changement de type est un opérateur (en fait une noria d’opérateurs, puisqu’il y en a autant que le nombre de types). Pour un type donné, il peut s’écrire de deux façons différentes lorsqu’on l’utilise soit sous la forme opératoire (type) x, soit sous la forme fonctionnelle type(x). Dans tous les cas, c’est un opérateur unaire, de nom operator type() (mais pas operator(type)() qui provoquerait une erreur). La syntaxe est un peu spéciale, en ce sens qu’aucun type résultat n’est à déclarer (c’est en fait type), c’est-à-dire qu’on n’écrit pas type operator type() mais directement operator type() dans la classe (ce doit être une méthode obligatoirement).

Voici par exemple une définition de changement de type de fraction vers double tout à fait naturelle :

class fraction {     // ... comme ci-avant     operator double() { return num/ double(den); }     };

On peut alors écrire :

fraction f(3,17);   // donne 3/17double d = double(f);        // ou encore d = (double)f;

Notons que la définition d’un opérateur inverse, de fraction vers double, est plus problématique, car les fractions ne sont pas généralement représentables exactement dans un nombre à virgule flottante. La conversion inverse exige donc une définition d’une notion de précision.

Les opérateurs de conversion ne peuvent avoir pour arguments que des classes nouvellement définies, comme on l’a dit au paragraphe précédent. En conséquence, on ne peut pas créer un opérateur operator fraction(long) par exemple.

Nous connaissons cependant déjà la solution à ce problème : il suffit d’écrire un constructeur fraction::fraction(long) dont l’effet sera strictement identique. C’est d’ailleurs ce que nous avons fait précédemment.

Précédent

Sommaire

Suivant