float_control pragma

Specifica il comportamento a virgola mobile per una funzione.

Sintassi

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

Opzioni

precise, on | off, push
Specifica se abilitare (on) o disabilitare (off) la semantica a virgola mobile precisa. Per informazioni sulle differenze con l'opzione del /fp:precise compilatore, vedere la sezione Osservazioni. Il token facoltativo push esegue il push dell'impostazione corrente per float_control nello stack del compilatore interno.

except, on | off, push
Specifica se abilitare () o disabilitare (onoff) la semantica delle eccezioni a virgola mobile. Il token facoltativo push esegue il push dell'impostazione corrente per float_control nello stack del compilatore interno.

except può essere impostato solo su on quando precise è impostato anche su on.

push
Esegue il push dell'impostazione corrente float_control nello stack del compilatore interno.

pop
Rimuove l'impostazione float_control dalla parte superiore dello stack del compilatore interno e imposta la nuova float_control impostazione.

Osservazioni:

non float_controlpragma ha lo stesso comportamento dell'opzione del /fp compilatore. L'unica float_controlpragma regola parte del comportamento a virgola mobile. Deve essere combinato con fp_contract le direttive e fenv_accesspragma per ricreare le opzioni del /fp compilatore. La tabella seguente illustra le impostazioni equivalenti pragma per ogni opzione del compilatore:

In altre parole, potrebbe essere necessario usare diverse pragma direttive in combinazione per emulare le /fp:fastopzioni della riga di comando , /fp:precisee /fp:strict .

Esistono restrizioni per i modi in cui è possibile usare le float_control direttive a virgola mobile pragma e fenv_access in combinazione:

• È possibile usare float_control per impostare su except on solo se è abilitata una semantica precisa. La semantica precisa può essere abilitata da float_controlpragmao tramite le opzioni del /fp:precise compilatore o /fp:strict .

• Non è possibile usare float_control per disattivare precise quando la semantica delle eccezioni è abilitata, indipendentemente da un'opzione float_controlpragma /fp:except del compilatore o .

• Non è possibile abilitare a fenv_access meno che non sia abilitata una semantica precisa, indipendentemente da un'opzione float_controlpragma del compilatore o da un'opzione del compilatore.

• Non è possibile usare float_control per disattivare precise quando fenv_access è abilitato.

Queste restrizioni indicano che l'ordine di alcune direttive a pragma virgola mobile è significativo. Per passare da un modello rapido a un modello rigoroso usando pragma direttive, usare il codice seguente:

#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

Per passare da un modello strict a un modello rapido usando , float_controlpragmausare il codice seguente:

#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 non vengono specificate opzioni, float_control non ha alcun effetto.

Esempio

L'esempio seguente illustra come intercettare un'eccezione a virgola mobile overflow 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

Vedi anche

Pragmadirettive e parole __pragma chiave e _Pragma
fenv_access pragma
fp_contract pragma