_controlfp_s

Article
03/04/2013

obtient et définit le mot de commande à virgule flottante.Il s'agit d'une version de _control87, _controlfp, __control87_2 avec des améliorations de sécurité comme décrit dans Fonctionnalités de sécurité du CRT.

errno_t _controlfp_s(
    unsigned int *currentControl,
    unsigned int newControl,
    unsigned int mask
);

Paramètres

currentControl
La valeur binaire actuelle de contrôle-Word.
newControl
Nouvelles valeurs de bits de contrôle-Word.
mask
Masquez pour que les nouveaux éléments de contrôle-Word définissent.

Valeur de retour

Zéro si l'opération a réussi ou un code d'erreur de valeur d' errno .

Notes

_controlfp_s est un plateforme-indépendant et plus la version sécurisée d' _control87, inséré et définit le mot de commande à virgule flottante dans l'adresse d' currentControl et d' newControl, respectivement.Les bits dans les valeurs indiquent l'état du contrôle à virgule flottante.L'état du contrôle à virgule flottante permet au programme de modifier la précision, l'arrondi, et les modes de l'infini dans le package mathématiques à virgule flottante.Il peut également masquer ou démasquer des exceptions de virgule flottante à l'aide de _controlfp_s.

Si la valeur de mask est égale à 0, _controlfp_s obtient le mot de commande à virgule flottante et stocke la valeur récupérée dans currentControl.

si mask est différent de zéro, une nouvelle valeur pour le mot de commande est définie : Pour tout bits qui est activé (égale à 1) dans mask, le bit correspondant dans new est utilisé pour mettre à jour le mot de commande.en d'autres termes, fpcntrl = ((fpcntrl & ~mask) | (new & mask)) où fpcntrl est le mot de commande à virgule flottante.Dans ce scénario, currentControl a la valeur après la modification se termine ; ce n'est pas la valeur binaire ancienne de contrôle-Word.

[!REMARQUE]

Les bibliothèques Runtime masquent les exceptions de virgule flottante par défaut.

_controlfp_s est quasiment identique à la fonction d' _control87 sur les plateformes Intel (x86) et est pris en charge par MIPS et les ALPHAS plateformes.Pour s'assurer que le code à virgule flottante est portable à MIPS ou à l'ALPHA, utilisez _controlfp_s.Si vous ciblez des plateformes x86, utilisez _control87ou _controlfp_s.

La différence entre _control87et _controlfp_sest la façon dont ces valeurs d' DENORMAL de traiter de deux fonctions.Pour les plateformes Intel (x86), _control87peut définir et effacer le masque d'exception d'OPÉRANDE de DENORMAL.Les ALPHAS plateformes ne prennent pas en charge cette exception, et _controlfp_sne modifie pas le masque d'exception d'OPÉRANDE de DENORMAL.L'exemple suivant illustre la différence :

_control87( _EM_INVALID, _MCW_EM ); 
// DENORMAL is unmasked by this call.
_controlfp( _EM_INVALID, _MCW_EM ); 
// DENORMAL exception mask remains unchanged.

Les valeurs possibles pour la constante de masque (mask) et de nouvelles valeurs de contrôle (newControl) sont répertoriées dans le tableau suivant de valeurs hexadécimales.Utilisez des constantes portables répertoriées ci-dessous (_MCW_EM, _EM_INVALID, etc.) comme arguments à ces fonctions, plutôt qu'en fournissant des valeurs hexadécimales explicitement.

Les ALPHAS plateformes prennent en charge les valeurs d'entrée et de sortie de DENORMAL dans le logiciel.Le comportement par défaut de Windows NT sur ces plateformes est de purger les valeurs d'entrée et de sortie de DENORMAL à zéro._controlfp_s fournit un nouveau masque pour conserver et purger les valeurs de l'entrée et la sortie DENORMAL.

Les plateformes Intel (x86) prennent en charge les valeurs d'entrée et de sortie de DENORMAL au niveau matériel.le comportement est de conserver des valeurs de DENORMAL._control87 ne fournit pas de masque pour modifier ce comportement.L'exemple suivant illustre cette différence :

controlfp( _DN_SAVE, _MCW_DN);   
// Denormal values preserved by software on ALPHA. NOP on x86
controlfp( _DN_FLUSH, _MCW_DN);   
// Denormal values flushed to zero by hardware on ALPHA. Ignored on x86

_controlfp_s affecte les mots de commande pour le x87 et le SSE2, le cas échéant.Il est possible que les deux mots de commande soient incohérent entre eux (en raison d'un appel précédent à __control87_2, par exemple) ; s'il existe une incohérence entre les deux mots de commande, _controlfp_s définit la balise d' EM_AMBIGUOUS dans currentControl.Il s'agit d'un avertissement indiquant que le mot de commande retourné ne peut pas représenter l'état des deux mots de commande à virgule flottante exactement.

sur l'architecture de x64 , modifier la précision de virgule flottante n'est pas pris en charge.si le masque de contrôle de précision est utilisé sur cette plateforme, le gestionnaire de paramètre non valide est appelé, comme décrit dans Validation des paramètres.

si le masque n'est pas défini correctement, cette fonction génère une exception de paramètre non valide, comme décrit dans Validation des paramètres.Si est autorisé à l'exécution de se poursuivre, retourne EINVAL de cette fonction et définit errno à EINVAL.

Cette fonction est déconseillée lors de la compilation avec /clr (Compilation pour le Common Language Runtime) ou /clr:pure car le common langage runtime prend en charge uniquement la précision de virgule flottante par défaut.

valeurs hexadécimales

Pour le masque d' _MCW_EM , désactiver le masque définit l'exception, qui permet l'exception matériels ; définir le masque masque l'exception.Notez que si _EM_UNDERFLOW ou _EM_OVERFLOW se produit, aucune exception de matériel n'est levée jusqu'à ce que l'instruction à virgule flottante suivante ne soit exécutée.Pour générer une exception de matériel immédiatement après _EM_UNDERFLOW ou _EM_OVERFLOW, appelez l'instruction de FWAIT MASM.

Masque	Valeur hexadécimal	Constante	Valeur hexadécimal
_MCW_DN (contrôle " Denormal ")	0x03000000	_DN_SAVE _DN_FLUSH	0x00000000 0x01000000
_MCW_EM (masque d'exception d'interruption)	0x0008001F	_EM_INVALID _EM_DENORMAL _EM_ZERODIVIDE _EM_OVERFLOW _EM_UNDERFLOW _EM_INEXACT	0x00000010 0x00080000 0x00000008 0x00000004 0x00000002 0x00000001
_MCW_IC (contrôle de l'infini)	0x00040000	_IC_AFFINE _IC_PROJECTIVE	0x00040000 0x00000000
_MCW_RC (contrôle d'arrondi)	0x00000300	_RC_CHOP _RC_UP _RC_DOWN _RC_NEAR	0x00000300 0x00000200 0x00000100 0x00000000
_MCW_PC (contrôle de précision)	0x00030000	_PC_24 (24 bits) _PC_53 (53 bits) _PC_64 (64 bits)	0x00020000 0x00010000 0x00000000

Configuration requise

routine	en-tête requis
_controlfp_s	<float.h>

Pour plus d'informations de compatibilité, consultez compatibilité dans l'introduction.

Exemple

// crt_contrlfp_s.c
// processor: x86
// This program uses _controlfp_s to output the FP control 
// word, set the precision to 24 bits, and reset the status to 
// the default.
//

#include <stdio.h>
#include <float.h>
#pragma fenv_access (on)

int main( void )
{
    double a = 0.1;
    unsigned int control_word;
    int err;

    // Show original FP control word and do calculation.
    err = _controlfp_s(&control_word, 0, 0);
    if ( err ) /* handle error here */;

    printf( "Original: 0x%.4x\n", control_word );
    printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );

    // Set precision to 24 bits and recalculate.
    err = _controlfp_s(&control_word, _PC_24, MCW_PC);
    if ( err ) /* handle error here */;

    printf( "24-bit:   0x%.4x\n", control_word );
    printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );

    // Restore default precision-control bits and recalculate.
    err = _controlfp_s(&control_word, _CW_DEFAULT, MCW_PC);
    if ( err ) /* handle error here */;

    printf( "Default:  0x%.4x\n", control_word );
    printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
}

Sortie

Original: 0x9001f
0.1 * 0.1 = 1.000000000000000e-002
24-bit:   0xa001f
0.1 * 0.1 = 9.999999776482582e-003
Default:  0x9001f
0.1 * 0.1 = 1.000000000000000e-002

Équivalent.NET framework

Non applicable.Pour appeler la fonction C standard, utilisez PInvoke.Pour plus d'informations, consultez l' exemples d'appel de code non managé.

Voir aussi

Référence

Support à virgule flottante

_clear87, _clearfp

_status87, _statusfp, _statusfp2

Partager via