float_control pragma

Spécifie le comportement de virgule flottante d'une fonction.

Syntaxe

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

Options

precise, , on | offpush
Spécifie s’il faut activer (on) ou désactiver (off) une sémantique à virgule flottante précise. Pour plus d’informations sur les différences avec l’option du /fp:precise compilateur, consultez la section Remarques. Le jeton facultatif push envoie (push) le paramètre actuel pour float_control la pile du compilateur interne.

except, , on | offpush
Spécifie s’il faut activer (on) ou désactiver (off) la sémantique d’exception à virgule flottante. Le jeton facultatif push envoie (push) le paramètre actuel pour float_control la pile du compilateur interne.

except ne peut être défini on que sur quand precise est également défini sur on.

push
Envoie (push) le paramètre actuel float_control sur la pile du compilateur interne.

pop
Supprime le float_control paramètre du haut de la pile du compilateur interne et rend ce nouveau float_control paramètre.

Notes

Le float_controlpragma comportement n’est pas le même que celui de l’option du /fp compilateur. La float_controlpragma seule partie du comportement à virgule flottante est régie. Il doit être combiné avec fp_contract les directives et fenv_accesspragma les directives pour recréer les options du /fp compilateur. Le tableau suivant présente les paramètres équivalents pragma pour chaque option du compilateur :

Option	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

* Dans les versions de Visual Studio avant Visual Studio 2022, le /fp:precise comportement par défaut est défini fp_contract(on)sur .

En d’autres termes, vous devrez peut-être utiliser plusieurs pragma directives en combinaison pour émuler les /fp:fastoptions , /fp:preciseet /fp:strict de ligne de commande.

Il existe des restrictions sur les façons dont vous pouvez utiliser les float_control fenv_access directives à virgule pragma flottante en combinaison :

• Vous ne pouvez utiliser float_control que pour définir on except la sémantique précise si la sémantique est activée. La sémantique précise peut être activée par le float_controlpragmaou à l’aide des options du /fp:precise compilateur./fp:strict

• Vous ne pouvez pas utiliser float_control pour désactiver precise lorsque la sémantique d’exception est activée, qu’il s’agisse d’une option de compilateur ou d’une float_controlpragma /fp:except option de compilateur.

• Vous ne pouvez pas activer fenv_access , sauf si la sémantique précise est activée, qu’il s’agisse d’une float_controlpragma option de compilateur ou d’une option de compilateur.

• Vous ne pouvez pas utiliser float_control pour désactiver precise le moment où fenv_access elle est activée.

Ces restrictions signifient que l’ordre de certaines directives à virgule pragma flottante est important. Pour passer d’un modèle rapide à un modèle strict à l’aide pragma de directives, utilisez le code suivant :

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

Pour passer d’un modèle strict à un modèle rapide à l’aide du float_controlpragmacode suivant :

#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

Si aucune option n’est spécifiée, float_control n’a aucun effet.

La float_control directive désactive les contractions lorsqu’elle est activée precise ou except. float_control Utiliser pour désactiver ou except restaurer precise le paramètre précédent pour les contractions. Vous pouvez utiliser la fp_contractpragma directive pour modifier le comportement du compilateur sur les contractions. float_control(push) et envoyer (push) et float_control(pop) afficher le paramètre pour les contractions dans le float_control cadre du paramètre sur la pile du compilateur interne. Ce comportement est nouveau dans Visual Studio 2022. La float_control directive dans les versions précédentes du compilateur n’a pas affecté les paramètres de contraction.

Exemple

L’exemple suivant montre comment intercepter une exception à virgule flottante de dépassement à l’aide pragmafloat_controlde .

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

Voir aussi

Pragma directives et mots __pragma _Pragma clés
fenv_access pragma
fp_contract pragma