Operadores Aritméticos

Este tópico descreve os operadores aritméticos disponíveis em F#.

Resumo dos operadores aritméticos binários

As operações aritméticas em F# podem ser realizadas em dois modos: Sem verificação e Com verificação. Por padrão, as operações aritméticas utilizam um comportamento não controlado, que prioriza o desempenho, mas permite transbordo/subfluxo. Os operadores verificados dão prioridade à segurança, lançando exceções nesses casos.

Operadores aritméticos não verificados

A tabela a seguir resume os operadores binários de aritmética que estão disponíveis para a Aritmética Não Verificada com tipos integrais e de ponto flutuante não encaixotados.

Operador binário	Observações
+ (adição, mais)	Desmarcado. Possível condição de estouro quando os números são adicionados e a soma excede o valor absoluto máximo suportado pelo tipo.
- (subtração, menos)	Desmarcado. Possível condição de subfluxo quando tipos não assinados são subtraídos ou quando os valores de vírgula flutuante são muito pequenos para serem representados pelo tipo.
* (multiplicação, vezes)	Desmarcado. Possível condição de excesso quando os números são multiplicados e o resultado do produto excede o valor absoluto máximo suportado pelo tipo.
/ (divisão, dividida por)	A divisão por zero causa um DivideByZeroException para tipos inteiros. Para tipos de vírgula flutuante, a divisão por zero dá-lhe os valores especiais de vírgula flutuante infinity ou -infinity. Há também uma possível condição de subfluxo quando um número de vírgula flutuante é muito pequeno para ser representado pelo tipo.
% (restante, rem)	Retorna o restante de uma operação de divisão. O sinal do resultado é o mesmo que o sinal do primeiro operando.
** (exponenciação, ao poder de)	Possível condição de transbordo quando o resultado excede o valor absoluto máximo para o tipo. O operador de exponenciação funciona apenas com tipos de ponto flutuante.

O comportamento não verificado não lança exceções quando ocorre estouro ou subfluxo, tornando-o menos seguro para aritmética em valores grandes ou extremos.

Operadores aritméticos verificados

A tabela a seguir resume os operadores aritméticos binários que estão disponíveis para Aritmética Verificada com tipos integrais não encaixotados. Os operadores verificados garantem que os cálculos sejam verificados quanto a transbordamento ou subfluxo, fornecendo aritmética mais segura para aplicações críticas.

Operador binário	Observações
+ (adição, mais)	Lança uma OverflowException se o resultado exceder o valor máximo ou for inferior ao valor mínimo suportado pelo tipo. Tanto Overflow quanto Underflow são possíveis.
- (subtração, menos)	Lança uma OverflowException se o resultado exceder o valor máximo ou for inferior ao valor mínimo suportado pelo tipo. Tanto Overflow quanto Underflow são possíveis.
* (multiplicação, vezes)	Lança um OverflowException se o produto exceder o valor máximo ou ficar abaixo do valor mínimo suportado pelo tipo. Tanto de sobrecarga quanto de subcarga são possíveis.

Os operadores verificados são úteis para garantir que os excessos aritméticos são detetados e tratados explicitamente.

Aqui está um exemplo:

open Microsoft.FSharp.Core.Operators.Checked

let safeAddition () =
    try
        let result = 2147483647 + 1 // Attempt to add integers at their maximum boundary
        printfn "Result: %d" result
    with
    | :? System.OverflowException as ex ->
        printfn "Overflow occurred: %s" ex.Message

safeAddition()

// Output:
// Overflow occurred: Arithmetic operation resulted in an overflow.

Escolhendo entre operadores verificados e não verificados

Operadores verificados: Ideal para cenários em que erros de overflow devem ser detetados e tratados explicitamente.

Operadores não verificados: Por padrão, o F# usa aritmética não verificada por motivos de desempenho. Essas operações podem produzir silenciosamente resultados incorretos quando ocorre transbordamento ou subfluxo. Use com cuidado.

Resumo dos Operadores Aritméticos Unários

A tabela a seguir resume os operadores aritméticos unários que estão disponíveis para tipos integrais e de vírgula flutuante.

Operador unário	Observações
+ (positivo)	Pode ser aplicado a qualquer expressão aritmética. Não altera o sinal do valor.
- (negação, negativo)	Pode ser aplicado a qualquer expressão aritmética. Altera o sinal do valor.

O comportamento em estouro ou subfluxo para tipos integrais é envolver. Isso causa um resultado incorreto. O estouro de número inteiro é um problema potencialmente sério que pode contribuir para problemas de segurança quando o software não é escrito para lidar com ele. Se isso for uma preocupação para a sua aplicação, considere usar os operadores verificados em Microsoft.FSharp.Core.Operators.Checked.

Resumo dos operadores de comparação binária

A tabela a seguir mostra os operadores de comparação binários que estão disponíveis para os tipos integral e de vírgula flutuante. Esses operadores retornam valores do tipo bool.

Números de ponto flutuante nunca devem ser comparados diretamente para igualdade, porque a representação de ponto flutuante IEEE não suporta uma operação de igualdade exata. Dois números que você pode verificar facilmente como iguais inspecionando o código podem, na verdade, ter representações de bits diferentes.

Operador	Observações
= (igualdade, igual)	Este não é um operador de atribuição. É usado apenas para comparação. Este é um operador genérico.
> (maior que)	Este é um operador genérico.
< (inferior a)	Este é um operador genérico.
>= (maior ou igual)	Este é um operador genérico.
<= (menor ou igual)	Este é um operador genérico.
<> (não igual)	Este é um operador genérico.

Operadores sobrecarregados e genéricos

Todos os operadores discutidos neste tópico são definidos no namespace Microsoft.FSharp.Core.Operators . Alguns dos operadores são definidos usando parâmetros de tipo resolvidos estaticamente. Isso significa que existem definições individuais para cada tipo específico que trabalha com esse operador. Todos os operadores aritméticos e à nível de bits unários e binários estão nesta categoria. Os operadores de comparação são genéricos e, portanto, trabalham com qualquer tipo, não apenas com tipos aritméticos primitivos. Os tipos de união e registro discriminados têm suas próprias implementações personalizadas que são geradas pelo compilador F#. Os tipos de classe usam o método Equals.

Os operadores genéricos são personalizáveis. Para personalizar as funções de comparação, substitua Equals para fornecer sua própria comparação de igualdade personalizada e, em seguida, implemente IComparable. A interface System.IComparable tem um único método, o método CompareTo.

Operadores e inferência de tipo

O uso de um operador em uma expressão restringe a inferência de tipo sobre esse operador. Além disso, o uso de operadores impede a generalização automática, porque o uso de operadores implica um tipo aritmético. Na ausência de qualquer outra informação, o compilador F# infere int como o tipo de expressões aritméticas. Você pode substituir esse comportamento especificando outro tipo. Assim, os tipos de argumento e o tipo de retorno de function1 no código a seguir são inferidos como int, mas os tipos para function2 são inferidos como 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

Ver também

• Símbolo e Referência do Operador
• Sobrecarga de Operador
• Operadores de Manipulação de Bits
• Operadores Booleanos