/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 que são representados na memória por menos de 80 bits, 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 manté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, é habilitada 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 manipulará corretamente 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 long double precision.
Multiplicação por exatamente 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 flutuantes expressões de ponto.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 está ativado.
/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 (extensões de linguagem Disable) (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.Anexar um sinal de menos à opção explicitamente a desabilita.strict
O modelo de ponto flutuante mais rígido./fp:strictfaz com que fp_contract a ser apagado e fenv_access esteja ativado./fp:exceptestá implícito e pode ser desabilitado, especificando explicitamente /fp:except-.Quando usado com /fp:except-, /fp:strict impõe estrita semântica de ponto flutuante, mas sem respeito por eventos excepcionais.
Comentários
Vários /fp opções podem ser especificadas na mesma compilação.
Para controlar o comportamento de ponto flutuante por função, consulte a 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 dependente da máquina./fp:stricte /fp:except não são compatíveis com /clr.
/fp:precisedeve resolver 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, você poderá usar /fp:fast.
/fp:strict, /fp:fast, e /fp:precise são os 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 ele processa pela última vez.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 Páginas de propriedades 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 Geração de código página de propriedades.
Modificar o Modelo de ponto flutuante propriedade.
Para definir essa opção de compilador programaticamente
- Consulte floatingPointModel.