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 :

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_controlfenv_access directives à virgule pragma flottante en combinaison :

• Vous ne pouvez utiliser float_control que pour définir excepton 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

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

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.

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

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