float_control pragma

Hiermee geeft u gedrag met drijvende komma op voor een functie.

Syntaxis

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

Opties

precise, on | off, push
Hiermee geeft u op of (on) of uitschakelen (off) nauwkeurige drijvendekomma-semantiek. Zie de sectie Opmerkingen voor informatie over verschillen met de optie /fp:precise compiler. Het optionele push token pusht de huidige instelling voor float_control op de interne compilerstack.

except, on | off, push
Hiermee geeft u op of de semantiek van drijvendekommagelingen (on) moet worden ingeschakeld of uitgeschakeld (off). Het optionele push token pusht de huidige instelling voor float_control op de interne compilerstack.

except kan alleen worden ingesteld op on wanneer precise ook is ingesteld op on.

push
Hiermee wordt de huidige float_control-instelling naar de interne compilerstack gepusht.

pop
Hiermee verwijdert u de float_control instelling boven aan de interne compilerstack en zorgt u ervoor dat de nieuwe float_control-instelling.

Opmerkingen

De float_controlpragma heeft niet hetzelfde gedrag als de /fp compileroptie. De float_controlpragma bepaalt alleen een deel van het drijvendekommagegedrag. Deze moet worden gecombineerd met fp_contract en fenv_accesspragma instructies om de /fp compileropties opnieuw te maken. In de volgende tabel ziet u de equivalente pragma instellingen voor elke compileroptie:

Optie	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

* In versies van Visual Studio vóór Visual Studio 2022 is het /fp:precise gedrag standaard ingesteld op fp_contract(on).

Met andere woorden, mogelijk moet u verschillende pragma instructies in combinatie gebruiken om de /fp:fast, /fp:preciseen /fp:strict opdrachtregelopties te emuleren.

Er gelden beperkingen voor de manieren waarop u de float_control en fenv_access drijvendekommage pragma instructies in combinatie kunt gebruiken:

• U kunt float_control alleen gebruiken om except in te stellen op on als nauwkeurige semantiek is ingeschakeld. Nauwkeurige semantiek kan worden ingeschakeld door de float_controlpragmaof met behulp van de /fp:precise of /fp:strict compileropties.

• U kunt float_control niet gebruiken om precise uit te schakelen wanneer de semantiek van uitzonderingen is ingeschakeld, ongeacht of deze zijn ingeschakeld door een float_controlpragma of een /fp:except compileroptie.

• U kunt fenv_access niet inschakelen, tenzij nauwkeurige semantiek is ingeschakeld, ongeacht of een float_controlpragma of een compileroptie.

• U kunt float_control niet gebruiken om precise uit te schakelen wanneer fenv_access is ingeschakeld.

Deze beperkingen betekenen dat de volgorde van een aantal drijvendekomma-pragma richtlijnen aanzienlijk is. Gebruik de volgende code om van een snel model naar een strikt model te gaan met behulp van pragma instructies:

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

Gebruik de volgende code om van een strikt model naar een snel model te gaan met behulp van de float_controlpragma:

#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

Als er geen opties zijn opgegeven, heeft float_control geen effect.

De float_control richtlijn schakelt contracties uit wanneer deze precise of exceptinschakelt. Gebruik van float_control om precise of except herstelt de vorige instelling voor contracties. U kunt de fp_contractpragma instructie gebruiken om het compilergedrag op samentrekkingen te wijzigen. float_control(push) en float_control(pop) de instelling voor samentrekkingen pushen en popen als onderdeel van de float_control-instelling op de interne compilerstack. Dit gedrag is nieuw in Visual Studio 2022. De float_control-instructie in eerdere compilerversies heeft geen invloed op contractie-instellingen.

Voorbeeld

In het volgende voorbeeld ziet u hoe u een overloopuitzondering met drijvende komma kunt ondervangen met behulp van 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

Zie ook

Pragma-instructies en de __pragma en _Pragma trefwoorden
fenv_access pragma
fp_contract pragma