/FP (especificar 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.Aumenta a consistência dos testes de ponto flutuante de igualdade e desigualdade desativando otimizações que poderiam alterar a precisão dos cálculos de ponto flutuante, que é necessário para conformidade com ANSI estrita.Por padrão, o compilador usa registros de 80 bit do co-processador para armazenar os resultados intermediários de cálculos de ponto flutuante.Isso aumenta a velocidade do programa e diminui o dimensionar do programa.Como o cálculo envolve tipos de dados de ponto flutuante são representados na memória por menos de 80 bits, entretanto, 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 longo pode produzir resultados divergente.
Com /fp:precise em x86 processadores, o compilador realizará arredondamento em variáveis do tipo float à 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 mais de um compilado sem /fp:precise. /fp:precise Desativa intrinsics; a biblioteca de time de execução padrão rotinas 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 substituir várias operações com uma operação composta com apenas um único arredondamento no participante, é habilitada com /fp:precise.
Otimizações expressão inválido 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 (veja IEEE 754 e o padrão C99).
O compilador manipulará corretamente comparações envolvendo NaN.Por exemplo, x != x é avaliada como True if x é NaN e ordenadas comparações envolvendo NaN disparar uma exceção.
Avaliação da expressão seguirá FLT_EVAL_METHOD C99 = 2, com uma exceção.Ao programar para x86 processadores, como o FPU está definido para precisão de 53 bit, isso será considerado de precisão dupla longa.
Multiplicação exatamente 1.0 transformado em um uso de outros fatores.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 ON desativa algumas otimizações, sistema autônomo avaliações de time de compilar de expressões de ponto flutuante. 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 não estará em vigor, a menos que fenv_access está ativado.
/fp:precise substitui o /Op opção do compilador.
fast
Cria o código mais rápido na maioria dos casos./fp:fast não pode ser usado com /fp:strict ou /fp:precise, a última opção especificada na linha de comando será usada. /fp:fast e /fp:except gerará um erro do compilador.Selecionando / Za, /Ze (linguagem desabilitar extensões) (ANSI compatibilidade) 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 precisão simples.
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.Acrescentar um sinal de subtração à opção explicitamente a desativa.strict
O modelo de ponto flutuante mais rígido./fp:strict faz com que fp_contract a ser apagado e fenv_access a ser ativado. /fp:except está implícito e pode ser desabilitado, explicitamente especificando /fp:except-. Quando usado com /fp:except-, /fp:strict impõe rigorosa 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 o float_control pragma.
Maioria das otimizações do ponto flutuante relacionadas a /fp:strict, /fp:except (e seu pragmas correspondente), e fp_contract pragma são dependente da computador. /fp:strict e /fp:except não são compatível com o /clr.
/fp:precise deve resolver a maioria dos requisitos de ponto flutuante de um aplicativo. Se necessário, você pode usar /fp:except e /fp:strict, mas pode haver alguma diminuir no desempenho. Se o desempenho for 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.If /fp:strict e /fp:precise são especificados, o compilador use aquela que processa pela última vez. Não é possível especificar ambos os /fp:strict e /fp:fast.
Para obter mais informações, consulte https://msdn.Microsoft.com/biblioteca/padrão.asp?url=/biblioteca/en-us/dv_vstechart/html/floapoint.ASP.
Para conjunto esta opção do compilador no ambiente de desenvolvimento do Visual Studio
em aberto propriedade Páginas caixa de diálogo.Para obter detalhes, consulte:Como: Abrir o Projeto Propriedade Páginas.
expandir o Propriedades de configuração nó.
expandir o C/C++ nó.
selecionar o Geração de código página de propriedades.
Modificar o Modelo de ponto flutuantepropriedade .