/FP (Especifica o comportamento de ponto flutuante)
Especifica o comportamento de ponto flutuante em um arquivo de código fonte.
/fp:[precise | except[-] | fast | strict ]
Sinalizadores
precise
O padrão.Melhora a consistência dos testes de ponto flutuante de igualdade e desigualdade desabilitando otimizações que poderiam alterar a precisão dos cálculos de ponto flutuante, que é necessário para conformidade estrita do ANSI. Por padrão, o compilador usa registradores de 80 bits do co-processador para manter os resultados intermediários de cálculos de ponto flutuante. Isso aumenta a velocidade de programa e diminui o tamanho do programa. Como o cálculo envolve os tipos de dados de ponto flutuante são representados por menos de 80 bits na memória, no entanto, carregando os bits extras de precisão (80 bits menos o número de bits em um tipo de ponto flutuante menor) por meio de um cálculo complexo pode produzir resultados inconsistentes.
Com /fp:precise em x86 processadores, o compilador realizará arredondamento em variáveis do tipo flutuante para a precisão adequada para as atribuições e projeções e quando passar parâmetros para uma função. Este arredondamento garante que os dados não retém qualquer significado maior que a capacidade do seu tipo. Um programa compilado com /fp:precise pode ser mais lento e maior do que um compilado sem /fp:precise. /fp:precisedesativa intrínsecos; as rotinas da biblioteca de tempo de execução padrão são usadas em vez disso. Para obter mais informações, consulte /Oi (gerar funções intrínsecas).
O seguinte comportamento de ponto flutuante é habilitado com /fp:precise:
Contrações ou substituição de várias operações com uma operação de composição com apenas um único arredondamento no final, é habilitado com /fp:precise.
Otimizações de expressão são inválidas para valores especiais (NaN, infinito, - infinito, + 0, 0) não serão permitidas. As otimizações de x-x => 0, x*0 => 0, x-0 => x, x+0 => x, e 0-x => -x são todos inválidos por vários motivos (consulte IEEE 754 e o padrão C99).
O compilador corretamente tratará comparações envolvendo NaN. Por exemplo, x != x for avaliada como true se x é NaN e ordenadas comparações envolvendo NaN elevar uma exceção.
A avaliação da expressão seguirá o FLT_EVAL_METHOD C99 = 2, com uma exceção. Ao programar para x86 processadores, porque o FPU está definida como a precisão de 53 bits, isso será considerado precision long double.
Multiplicação exatamente o 1.0 transformados em um fator de uso. x*y*1.0é transformado em x*y. Da mesma forma, x*1.0*y é transformado em x*y.
Divisão por exatamente 1.0 é transformado em um uso o dividendo. x*y/1.0é transformado em x*y. Da mesma forma, x/1.0*y é transformado em x*y.
Usando /fp:precise com fenv_access Diante desabilita algumas otimizações, como avaliações de tempo de compilação de flutuante ponto expressões. Por exemplo, se você alterar o modo de arredondamento com _control87, _controlfp, __control87_2e o compilador executa um cálculo de ponto flutuante, o modo de arredondamento especificado por você não estará em vigor, a menos que fenv_access é ON.
/fp:precisesubstitui o /Op opção de compilador.
fast
Cria o código mais rápido na maioria dos casos. /fp:fastnão pode ser usado com /fp:strict ou /fp:precise, a última opção especificada na linha de comando será usada. /fp:faste /fp:except irá gerar um erro do compilador.Selecionando / Za, /Ze (linguagem de desabilitar extensões) (compatibilidade ANSI) e /fp:fast pode resultar em comportamento inesperado. Por exemplo, as operações de ponto flutuante de precisão simples não podem ser arredondadas para precisão única.
except[-]
Modelo de exceção de ponto flutuante confiável. Exceções serão geradas imediatamente depois que são acionados. Essa opção está desativada por padrão. Acrescentando um sinal de subtração explicitamente a opção desativa a ele.strict
O modelo de ponto flutuante mais rígido. /fp:strictfaz com que fp_contract para ser desligado e fenv_access ON. /fp:exceptestá implícito e pode ser desabilitado especificando explicitamente /fp:except-. Quando usado com /fp:except-, /fp:strict impõe a semântica de ponto flutuante estrita, mas sem respeito por eventos excepcionais.
Comentários
Vários /fp opções podem ser especificadas no mesmo compilação.
Para controlar o comportamento de ponto flutuante por função, consulte o float_control pragma.
A maioria das otimizações de ponto flutuante relacionados a /fp:strict, /fp:except (e seu correspondente pragmas) e fp_contract pragma são dependentes da máquina. /fp:stricte /fp:except não compatíveis com /clr.
/fp:precisedeve atender a maioria das necessidades de ponto flutuante do aplicativo. Se necessário, você pode usar /fp:except e /fp:strict, mas pode haver alguma diminuição no desempenho. Se o desempenho é mais importante, convém usar /fp:fast.
/fp:strict, /fp:fast, e /fp:precise são modos de precisão (correção). Somente um pode estar em vigor por vez. Se /fp:strict e /fp:precise estiver especificado, o compilador usar aquele que processa por último. Não é possível especificar ambos /fp:strict e /fp:fast.
Para obter mais informações, consulte https://msdn.microsoft.com/library/default.asp?url=/library/en-us/dv_vstechart/html/floapoint.asp.
Para definir esta opção de compilador no ambiente de desenvolvimento Visual Studio
Abra o projeto Property Pages caixa de diálogo. Para obter detalhes, consulte:Como: Abrir páginas de propriedades do projeto.
Expanda o Propriedades de configuração nó.
Expanda o C/C++ nó.
Selecione o A geração de código página de propriedades.
Modificar o Modelo de ponto flutuante propriedade.
Para definir esta opção de compilador programaticamente
- Consulte floatingPointModel.