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
| off
, push
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
| off
, push
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_control
pragma comportement n’est pas le même que celui de l’option du /fp
compilateur. La float_control
pragma seule partie du comportement à virgule flottante est régie. Il doit être combiné avec fp_contract
les directives et fenv_access
pragma 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 .
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 |
En d’autres termes, vous devrez peut-être utiliser plusieurs pragma directives en combinaison pour émuler les /fp:fast
options , /fp:precise
et /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éfiniron
except
la sémantique précise si la sémantique est activée. La sémantique précise peut être activée par lefloat_control
pragmaou à l’aide des options du/fp:precise
compilateur./fp:strict
Vous ne pouvez pas utiliser
float_control
pour désactiverprecise
lorsque la sémantique d’exception est activée, qu’il s’agisse d’une option de compilateur ou d’unefloat_control
pragma/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’unefloat_control
pragma option de compilateur ou d’une option de compilateur.Vous ne pouvez pas utiliser
float_control
pour désactiverprecise
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_control
pragmacode 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_contract
pragma 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_control
de .
// 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(¤tControl, ~_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 __pragma
_Pragma
mot clé
fenv_access
pragma
fp_contract
pragma
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour