float_control pragma

Especifica o comportamento de ponto flutuante para uma função.

Sintaxe

#pragma float_control
#pragma float_control( precise, { on | off } [ , push ] )
#pragma float_control( except, { on | off } [ , push ] )
#pragma float_control( { push | pop } )

Opções

precise, on | off, push
Especifica se a semântica precisa de vírgula flutuante deve ser habilitada (on) ou desabilitada (off). Para obter informações sobre diferenças com a opção de compilador /fp:precise, consulte a seção Comentários. O token push opcional envia por push a configuração atual para float_control na pilha interna do compilador.

except, on | off, push
Especifica se a semântica de exceção de ponto flutuante deve ser habilitada (on) ou desabilitada (off). O token push opcional envia por push a configuração atual para float_control na pilha interna do compilador.

except só pode ser definido como on quando precise também estiver definido como on.

push
Envia a configuração float_control atual para a pilha interna do compilador.

pop
Remove a configuração float_control da parte superior da pilha interna do compilador e torna essa a nova configuração float_control.

Comentários

O float_controlpragma não tem o mesmo comportamento que a opção de compilador /fp. O float_controlpragma governa apenas parte do comportamento de ponto flutuante. Ele deve ser combinado com fp_contract e fenv_accesspragma diretivas para recriar as /fp opções do compilador. A tabela a seguir mostra as configurações de pragma equivalentes para cada opção do compilador:

Em outras palavras, talvez seja necessário usar várias diretivas pragma em combinação para emular as opções de linha de comando /fp:fast, /fp:precisee /fp:strict.

Existem restrições quanto às formas de utilizar as diretivas float_control e fenv_accesspragma de ponto flutuante em combinação:

• Você só pode usar float_control para definir except como on se a semântica precisa estiver habilitada. A semântica precisa pode ser ativada pelo float_controlpragmaou usando as opções /fp:precise ou /fp:strict compilador.

• Não é possível usar float_control para desativar precise quando a semântica de exceção está habilitada, seja por uma opção de compilador float_controlpragma ou /fp:except.

• Você não pode habilitar fenv_access a menos que semânticas precisas estejam habilitadas, seja por um float_controlpragma ou uma opção de compilador.

• Não é possível usar float_control para desativar precise quando o fenv_access estiver habilitado.

Estas restrições significam que a ordem de algumas diretivas pragma de ponto flutuante é significativa. Para passar de um modelo rápido para um modelo rigoroso usando diretivas pragma, use o seguinte código:

#pragma float_control(precise, on)  // enable precise semantics
#pragma fenv_access(on)             // enable environment sensitivity
#pragma float_control(except, on)   // enable exception semantics

#pragma float_control(precise, on)  // enable precise semantics
#pragma fenv_access(on)             // enable environment sensitivity
#pragma float_control(except, on)   // enable exception semantics
#pragma fp_contract(off)            // disable contractions

Para passar de um modelo estrito para um modelo rápido usando o float_controlpragma, use o seguinte código:

#pragma float_control(except, off)  // disable exception semantics
#pragma fenv_access(off)            // disable environment sensitivity
#pragma float_control(precise, off) // disable precise semantics
#pragma fp_contract(on)             // enable contractions

Se nenhuma opção for especificada, float_control não terá efeito.

Exemplo

O exemplo a seguir mostra como capturar uma exceção de ponto flutuante de estouro usando pragmafloat_control.

// pragma_directive_float_control.cpp
// compile with: /EHa
#include <stdio.h>
#include <float.h>

double func( ) {
   return 1.1e75;
}

#pragma float_control (except, on)

int main( ) {
   float u[1];
   unsigned int currentControl;
   errno_t err;

   err = _controlfp_s(&currentControl, ~_EM_OVERFLOW, _MCW_EM);
   if (err != 0)
      printf_s("_controlfp_s failed!\n");

   try  {
      u[0] = func();
      printf_s ("Fail");
      return(1);
   }

   catch (...)  {
      printf_s ("Pass");
      return(0);
   }
}

Pass

Ver também

diretivas Pragma e as palavras-chave __pragma e _Pragma
fenv_access pragma
fp_contract pragma