float_control pragma

Függvény lebegőpontos viselkedését adja meg.

Szintaxis

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

Beállítások

precise, on | off, push
Megadja, hogy engedélyezni (on) vagy letiltani (off) a pontos lebegőpontos szemantikát. A /fp:precise fordítóval való különbségekről a Megjegyzések szakaszban talál további információt. Az opcionális push token leküldi a belső fordítóverem float_control aktuális beállítását.

except, on | off, push
Megadja, hogy engedélyezni (on) vagy letiltani (off) a lebegőpontos kivétel szemantikáját. Az opcionális push token leküldi a belső fordítóverem float_control aktuális beállítását.

except csak akkor állítható be on, ha precise is be van állítva on.

push
Az aktuális float_control beállítást a belső fordítóverembe küldi.

pop
Eltávolítja a float_control beállítást a belső fordítóverem tetejéről, és ezt teszi az új float_control beállítássá.

Megjegyzések

A float_controlpragma nem ugyanaz a viselkedése, mint a /fp fordítóbeállításnak. A float_controlpragma csak a lebegőpontos viselkedés egy részét szabályozza. A /fp fordítóbeállítások újbóli létrehozásához fp_contract és fenv_accesspragma irányelvekkel kell kombinálni. Az alábbi táblázat az egyes fordítóbeállítások egyenértékű pragma beállításait mutatja be:

Opció	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

* A Visual Studio 2022 előtti verziókban a /fp:precise viselkedés alapértelmezés szerint fp_contract(on).

Más szóval előfordulhat, hogy a /fp:fast, /fp:preciseés /fp:strict parancssori beállítások emulálásához több pragma direktívát kell használnia.

Az float_control és a lebegőpontos fenv_accesspragma irányelvek együttes használatára korlátozások vonatkoznak:

• A float_control csak akkor állíthat be excepton, ha a pontos szemantikák engedélyezve vannak. A pontos szemantikát a float_controlpragma, vagy a /fp:precise vagy /fp:strict fordító beállításaival engedélyezheti.

• A float_control nem kapcsolhatja ki a precise, ha a kivétel szemantikája engedélyezve van, akár float_controlpragma, akár /fp:except fordítóbeállítással.

• A fenv_access csak akkor engedélyezheti, ha a pontos szemantika engedélyezve van, akár float_controlpragma, akár fordítóbeállítással.

• A float_control nem kapcsolhatja ki precise, ha fenv_access engedélyezve van.

Ezek a korlátozások azt jelentik, hogy egyes lebegőpontos pragma irányelvek sorrendje jelentős. Ha gyors modellről szigorú modellre szeretne lépni pragma irányelvek használatával, használja a következő kódot:

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

Ha szigorú modellről gyors modellre szeretne lépni a float_controlpragmahasználatával, használja a következő kódot:

#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

Ha nincs megadva beállítás, float_control nincs hatása.

A float_control irányelv letiltja az összehúzódásokat, amikor bekapcsolja precise vagy except. A float_control használatával kikapcsolhatja precise vagy except visszaállítja az előző beállítást a kontrakciókhoz. A fp_contractpragma irányelv használatával módosíthatja a fordító működését a kontrakciók esetében. float_control(push) és float_control(pop) a float_control beállítás részeként leküldi és leküldi a float_control beállítást a belső fordítóverembe. Ez a viselkedés új a Visual Studio 2022-ben. A float_control korábbi fordítóverziók irányelve nem befolyásolta a kontrakciós beállításokat.

Példa

Az alábbi minta bemutatja, hogyan lehet észlelni egy túlcsorduló lebegőpontos kivételt pragmafloat_controlhasználatával.

// 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

Lásd még:

Pragma irányelvei, valamint a __pragma és _Pragma kulcsszavak
fenv_access pragma
fp_contract pragma