float_control pragma

Určuje chování funkce s plovoucí desetinou čárkou.

Syntaxe

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

Možnosti

precise, , on | offpush
Určuje, jestli chcete povolit (on) nebo zakázat (off) přesnou sémantiku s plovoucí desetinnou čárkou. Informace o rozdílech s možností kompilátoru /fp:precise najdete v části Poznámky. Volitelný push token odešle aktuální nastavení pro float_control interní zásobník kompilátoru.

except, , on | offpush
Určuje, jestli chcete povolit (on) nebo zakázat sémantikuoff výjimky s plovoucí desetinnou čárkou. Volitelný push token odešle aktuální nastavení pro float_control interní zásobník kompilátoru.

except lze nastavit on pouze tehdy, je-li precise nastavena na onhodnotu .

push
Nasdílí aktuální float_control nastavení do interního zásobníku kompilátoru.

pop
Odebere float_control nastavení z horní části interního zásobníku kompilátoru a vytvoří nové float_control nastavení.

Poznámky

Nemá float_controlpragma stejné chování jako možnost kompilátoru /fp . Jediná float_controlpragma část chování s plovoucí desetinou čárkou se řídí. Aby bylo možné znovu vytvořit možnosti kompilátorufp_contract, musí být kombinovány s fenv_access direktivami a pragma/fp direktivami. Následující tabulka uvádí ekvivalentní pragma nastavení pro každou možnost kompilátoru:

Možnost	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

* Ve verzích sady Visual Studio před sadou Visual Studio 2022 se /fp:precise chování ve výchozím nastavení nastaví na fp_contract(on).

Jinými slovy, může být nutné použít několik pragma direktiv v kombinaci emulace /fp:fast/fp:precise, a /fp:strict možnosti příkazového řádku.

Existují omezení způsobů použití float_control direktiv s fenv_access plovoucí desetinou čárkou pragma v kombinaci:

• K nastavení float_controlexcept můžete použít on pouze v případě, že je povolena přesná sémantika. Přesnou sémantiku může povolit buď float_controlpragmamožnost , nebo pomocí možností kompilátoru /fp:precise/fp:strict.

• Pokud je povolená sémantika výjimek, bez ohledu na float_controlprecise to, jestli je povolená možnost kompilátorufloat_control, nemůžete ji vypnout pragma/fp:except.

• Pokud není povolená přesná sémantika, ať fenv_accessfloat_control už možností kompilátoru, nemůžete pragma povolit.

• Pokud je tato možnost povolená, nemůžete ji vypnout float_controlprecisefenv_access .

Tato omezení znamenají, že pořadí některých direktiv s plovoucí desetinnou čárkou pragma je významné. Pokud chcete přejít z rychlého modelu na striktní direktivy using pragma modelu, použijte následující kód:

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

Pokud chcete přejít z striktního modelu na rychlý model pomocí float_controlpragmatohoto kódu, použijte následující kód:

#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

Pokud nejsou zadány žádné možnosti, float_control nemá žádný vliv.

Direktiva float_control zakáže kontrakce při zapnutí precise nebo except. float_control Použití k vypnutí precise nebo except obnovení předchozího nastavení pro kontrakty. Direktivu fp_contractpragma můžete použít ke změně chování kompilátoru při kontraktech. float_control(push) a float_control(pop) nasdílení a otevření nastavení pro kontrakty v rámci float_control nastavení do interního zásobníku kompilátoru. Toto chování je v sadě Visual Studio 2022 nové. Direktiva float_control v předchozích verzích kompilátoru neměla vliv na nastavení kontraktování.

Příklad

Následující příklad ukazuje, jak zachytit přetečení výjimky s plovoucí desetinou čárkou pomocí 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

Viz také

direktivy Pragma a __pragma a _Pragma klíčová slova
fenv_access pragma
fp_contract pragma