Operadores aritméticos

Este tópico descreve operadores aritméticos que estão disponíveis em F#.

Resumo dos operadores aritméticos binários

As operações aritméticas em F# podem ser executadas em dois modos: Desmarcado e Verificado. Por padrão, as operações aritméticas usam um comportamento desmarcado, que prioriza o desempenho, mas permite estouro/subfluxo. Os operadores verificados priorizam a segurança lançando exceções nesses casos.

Operadores aritméticos desmarcados

A tabela a seguir resume os operadores aritméticos binários que estão disponíveis para a Aritmética Desmarcada com tipos de ponto flutuante e integrais sem caixa.

O comportamento desmarcado não gera exceções quando ocorre estouro ou subfluxo, tornando-o menos seguro para aritmética em valores grandes ou de borda.

Operadores aritméticos verificados

A tabela a seguir resume os operadores aritméticos binários que estão disponíveis para a Aritmética Marcada com tipos integrais sem caixa. Os operadores verificados garantem que os cálculos sejam verificados para estouro ou subfluxo, fornecendo aritmética mais segura para aplicativos críticos.

Os operadores verificados são úteis para garantir que estouros aritméticos sejam capturados 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 desmarcados

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

Operadores desmarcados: Por padrão, o F# usa aritmética desmarcada por motivos de desempenho. Essas operações podem produzir silenciosamente resultados incorretos quando ocorre estouro ou subfluxo. Use-o 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 ponto flutuante.

O comportamento em estouro ou subfluxo para tipos integrais é encapsular. Isso causa um resultado incorreto. O estouro de inteiros é um problema potencialmente sério que pode contribuir para problemas de segurança quando o software não é gravado para contabilizar isso. Se isso for uma preocupação para seu aplicativo, 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ária disponíveis para tipos integrais e de ponto flutuante. Esses operadores retornam valores do tipo bool.

Os números de ponto flutuante nunca devem ser comparados diretamente quanto à igualdade, pois a representação de ponto flutuante do IEEE não dá suporte a uma operação de igualdade exata. Dois números que você pode verificar facilmente como iguais inspecionando o código podem ter representações de bits diferentes.

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 há definições individuais para cada tipo específico que funciona com esse operador. Todos os operadores aritméticos e bit aritméticos binários e unários estão nessa categoria. Os operadores de comparação são genéricos e, portanto, funcionam com qualquer tipo, não apenas com tipos aritméticos primitivos. Os tipos de registro e união 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 implemente IComparable. A System.IComparable interface tem um único método, o CompareTo método.

Operadores e inferência de tipo

O uso de um operador em uma expressão restringe a inferência de tipo nesse operador. Além disso, o uso de operadores impede a generalização automática, pois 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. Portanto, os tipos de argumento e o tipo de retorno do function1 código a seguir são inferidos para serem int, mas os tipos para function2 os quais são inferidos serão 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

Consulte também

• Referência de símbolo e operador
• Sobrecarga de operador
• operadores bit a bit
• Operadores Boolianos