float_control pragma

Anger flyttalsbeteende för en funktion.

Syntax

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

Alternativ

precise, on | off, push
Anger om du vill aktivera (on) eller inaktivera (off) exakta flyttalssemantik. Information om skillnader med alternativet /fp:precise kompilator finns i avsnittet Anmärkningar. Den valfria push token push-överför den aktuella inställningen för float_control på den interna kompilatorstacken.

except, on | off, push
Anger om du vill aktivera (on) eller inaktivera (off) flyttal undantagssemantik. Den valfria push token push-överför den aktuella inställningen för float_control på den interna kompilatorstacken.

except kan bara anges till on när precise också är inställt på on.

push
Push-överför den aktuella inställningen float_control till den interna kompilatorstacken.

pop
Tar bort inställningen float_control överst i den interna kompileringsstacken och gör den till den nya inställningen float_control.

Anmärkningar

float_control pragma har inte samma beteende som /fp kompilatoralternativet. float_control pragma styr bara en del av flyttalsbeteendet. Det måste kombineras med fp_contract- och fenv_accesspragma-direktiv för att återskapa /fp kompilatoralternativ. I följande tabell visas motsvarande pragma inställningar för varje kompilatoralternativ:

Alternativ	float_control(precise, *)	float_control(except, *)	fp_contract(*)	fenv_access(*)
/fp:strict	on	on	off	on
/fp:precise	on	off	off*	off
/fp:fast	off	off	on	off

* I versioner av Visual Studio före Visual Studio 2022 har det /fp:precise beteendet som standard fp_contract(on).

Med andra ord kan du behöva använda flera pragma-direktiv i kombination för att emulera kommandoradsalternativen /fp:fast, /fp:preciseoch /fp:strict.

Det finns begränsningar för hur du kan använda float_control- och fenv_access flyttal pragma direktiv i kombination:

• Du kan bara använda float_control för att ange except till on om exakta semantik är aktiverade. Exakta semantik kan aktiveras antingen av float_controlpragmaeller med hjälp av /fp:precise eller /fp:strict kompilatoralternativ.

• Du kan inte använda float_control för att inaktivera precise när undantagssemantik aktiveras, oavsett om det är ett float_controlpragma eller ett /fp:except kompilatoralternativ.

• Du kan inte aktivera fenv_access om inte exakta semantik är aktiverade, oavsett om det är ett float_controlpragma eller ett kompilatoralternativ.

• Du kan inte använda float_control för att inaktivera precise när fenv_access är aktiverat.

Dessa begränsningar innebär att ordningen på vissa flyttalsdirektiv pragma är betydande. Om du vill gå från en snabb modell till en strikt modell med pragma-direktiv använder du följande kod:

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

Om du vill gå från en strikt modell till en snabb modell med hjälp av float_controlpragmaanvänder du följande kod:

#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

Om inga alternativ anges har float_control ingen effekt.

float_control-direktivet inaktiverar sammandragningar när det aktiveras precise eller except. Användning av float_control för att inaktivera precise eller except återställer den tidigare inställningen för sammandragningar. Du kan använda fp_contractpragma-direktivet för att ändra kompilatorbeteendet för sammandragningar. float_control(push) och float_control(pop) push- och pop-inställningen för sammandragningar som en del av inställningen float_control på den interna kompilatorstacken. Det här beteendet är nytt i Visual Studio 2022. float_control-direktivet i tidigare kompilatorversioner påverkade inte inställningarna för kontraktion.

Exempel

Följande exempel visar hur du fångar ett undantag för spill med flyttals med hjälp av 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

Se även

Pragma-direktiv och nyckelorden __pragma och _Pragma
fenv_access pragma
fp_contract pragma