Partager via

Opérateurs arithmétiques

  • Article

Cette rubrique décrit les opérateurs arithmétiques disponibles dans F#.

Résumé des opérateurs arithmétiques binaires

Le tableau suivant résume les opérateurs arithmétiques binaires disponibles pour les types intégral et à virgule flottante non encadrés.

Opérateur binaire (binaryOperator) Notes
+ (addition, plus) Non vérifié. Condition de dépassement possible lorsque les nombres sont ajoutés ensemble et que la somme dépasse la valeur absolue maximale prise en charge par le type.
- (soustraction, moins) Non vérifié. Possibilité de débordement lorsque des types non signés sont soustraits ou lorsque des valeurs en virgule flottante sont trop petites pour être représentées par le type.
* (multiplication, heures) Non vérifié. Condition de dépassement possible lorsque les nombres sont multipliés et que le produit dépasse la valeur absolue maximale prise en charge par le type.
/ (division, divisé par) La division par zéro entraîne un DivideByZeroException de type intégral. Pour les types à virgule flottante, la division par zéro donne les valeurs spéciales à virgule flottante infinity ou -infinity. Il existe également une condition de sous-flux possible lorsqu’un nombre à virgule flottante est trop petit pour être représenté par le type.
% (reste, rem) Retourne le reste d'une division. Le signe du résultat est identique au signe du premier opérande.
** (exponentiation, à la puissance de) Condition de dépassement possible lorsque le résultat dépasse la valeur absolue maximale du type.

L’opérateur d’exposant fonctionne uniquement avec les types à virgule flottante.

Résumé des opérateurs arithmétiques unaires

Le tableau suivant récapitule les opérateurs arithmétiques unaires disponibles pour les types intégraux et à virgule flottante.

Opérateurs unaires Notes
+ (positif) Peut être appliqué à n’importe quelle expression arithmétique. Ne modifie pas le signe de la valeur.
- (négation, négatif) Peut être appliqué à n’importe quelle expression arithmétique. Permet de changer le signe de la valeur.

Le comportement au niveau du dépassement de capacité ou du flux de sortie pour les types intégraux consiste à un encapsulage. Cela provoque un résultat incorrect. Le dépassement d’entier est un problème potentiellement grave qui peut contribuer aux problèmes de sécurité lorsque le logiciel n’est pas écrit de manière à en tenir compte. Si cela pose un problème pour votre application, envisagez d'utiliser les opérateurs vérifiés dans Microsoft.FSharp.Core.Operators.Checked.

Résumé des opérateurs de comparaison binaire

Le tableau suivant présente les opérateurs de comparaison binaires disponibles pour les types intégraux et à virgule flottante. Ces opérateurs retournent des valeurs de type bool.

Les nombres à virgule flottante ne doivent jamais être comparés directement pour déterminer leur égalité, car la représentation IEEE des nombres à virgule flottante ne permet pas d'effectuer une opération d'égalité exacte. Deux nombres dont vous pouvez facilement vérifier l'égalité en inspectant le code peuvent en fait avoir des représentations différentes.

Opérateur Notes
= (égalité, égal à) Il ne s’agit pas d’un opérateur d’affectation. Il est utilisé uniquement pour la comparaison. Il s’agit d’un opérateur générique.
> (supérieur à) Il s’agit d’un opérateur générique.
< (inférieur à) Il s’agit d’un opérateur générique.
>= (supérieur ou égal à) Il s’agit d’un opérateur générique.
<= (inférieur ou égal à) Il s’agit d’un opérateur générique.
<> (non égal à) Il s’agit d’un opérateur générique.

Opérateurs surchargés et génériques

Tous les opérateurs abordés dans cette rubrique sont définis dans l’espace de noms Microsoft.FSharp.Core.Operators. Certains opérateurs sont définis à l'aide de paramètres de type résolus de manière statique. Cela signifie qu'il existe des définitions individuelles pour chaque type spécifique fonctionnant avec cet opérateur. Tous les opérateurs arithmétiques unaires et binaires ainsi que les opérateurs bitwise font partie de cette catégorie. Les opérateurs de comparaison sont génériques et fonctionnent donc avec n’importe quel type, pas seulement les types arithmétiques primitifs. Les types union et enregistrement différenciés ont leurs propres implémentations personnalisées qui sont générées par le compilateur F#. Les types de classes utilisent la méthode Equals.

Les opérateurs génériques sont personnalisables. Pour personnaliser les fonctions de comparaison, remplacez Equals pour fournir votre propre comparaison d’égalité personnalisée, puis implémentez IComparable. L’interface System.IComparable a une méthode unique, la méthode CompareTo.

Opérateurs et inférence de type

L’utilisation d’un opérateur dans une expression limite l’inférence de type sur cet opérateur. De plus, l’utilisation d’opérateurs empêche la généralisation automatique, car l’utilisation d’opérateurs implique un type arithmétique. En l’absence d’autres informations, le compilateur F# déduit int comme type d’expressions arithmétiques. Vous pouvez remplacer ce comportement en spécifiant un autre type. Ainsi, les types d'arguments et le type de retour de function1 dans le code suivant sont déduits comme étant int, mais les types pour function2 sont inférés comme étant float.

// x, y and return value inferred to be int
// function1: int -> int -> int
let function1 x y = x + y

// x, y and return value inferred to be float
// function2: float -> float -> float
let function2 (x: float) y = x + y

Voir aussi