_controlfp_s

Lekéri és beállítja a lebegőpontos vezérlő szót. Ennek a verziónak _control87_controlfp__control87_2 a biztonsági fejlesztései a CRT biztonsági funkcióiban leírtak szerint érhetők el.

Szemantika

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

Paraméterek

currentControl
Az aktuális vezérlőszavas bitérték.

newControl
Új vezérlőszavas bitértékek.

mask
Új vezérlőszavas bitek maszkolása.

Visszaadott érték

Sikeres esetben nulla, vagy errno értékhibakód.

Megjegyzések

A _controlfp_s függvény a platformfüggetlen és biztonságosabb verziója _control87, amely a lebegőpontos vezérlő szót a tárolt currentControl címbe helyezi, és a használatával newControlbeállítja. Az értékek bitjei a lebegőpontos vezérlő állapotát jelzik. A lebegőpontos vezérlési állapot lehetővé teszi, hogy a program a platformtól függően módosítsa a lebegőpontos matematikai csomag pontossági, kerekítési és végtelenségi módjait. A lebegőpontos kivételek maszkolására vagy maszkolására is használható _controlfp_s .

Ha az érték mask értéke 0, lekéri a lebegőpontos vezérlőszót, _controlfp_s és a beolvasott értéket a következőben currentControltárolja: .

Ha mask nem, akkor a vezérlőszó új értéke van beállítva: Minden olyan bitnél, amely be van állítva (azaz egyenlő 1) maska megfelelő bittel, a rendszer a vezérlőszó frissítésére használja a megfelelő bitet new . Más szóval, fpcntrl = ((fpcntrl & ~mask) | (newControl & mask)) hol fpcntrl van a lebegőpontos vezérlőszó. Ebben a forgatókönyvben currentControl a módosítás befejeződése után az értékre van állítva; nem a régi vezérlőszavas bitérték.

Megjegyzés:

Alapértelmezés szerint a futásidejű kódtárak elfedik az összes lebegőpontos kivételt.

_controlfp_s majdnem megegyezik az _control87 Intel (x86), x64 és ARM platformokon elérhető funkcióval. Ha x86, x64 vagy ARM platformot céloz meg, használhatja _control87 vagy _controlfp_s.

A különbség _control87_controlfp_s a denormális értékek között és abban van, hogy hogyan kezelik a denormális értékeket. Az Intel (x86), x64 és ARM platformok esetében _control87 beállíthatja és törölheti a DENORMAL OPERAND kivételmaszkot. _controlfp_s nem módosítja a DENORMAL OPERAND kivételmaszkot. Ez a példa a különbséget mutatja be:

_control87( _EM_INVALID, _MCW_EM );
// DENORMAL is unmasked by this call.
unsigned int current_word = 0;
_controlfp_s( &current_word, _EM_INVALID, _MCW_EM );
// DENORMAL exception mask remains unchanged.

A maszkállandó () és az új vezérlőértékek (masknewControl) lehetséges értékei a következő Hexadecimális értékek táblában láthatók. Használja az alább felsorolt hordozható állandókat (_MCW_EM_EM_INVALIDés így tovább) argumentumként ezeknek a függvényeknek a helyett, hogy explicit módon adja meg a hexadecimális értékeket.

Az Intel (x86)-alapú platformok támogatják a DENORMAL hardver bemeneti és kimeneti értékeit. Az x86-os viselkedés az értékek megőrzése DENORMAL . Az ARM-platform és az SSE2-támogatással rendelkező x64-platformok lehetővé teszik DENORMAL az operandusok és az eredmények kipirulásához vagy nullára kényszerítéséhez. A _controlfp_s, _controlfpés _control87 függvények maszkot biztosítanak a viselkedés módosításához. Az alábbi példa a maszk használatát mutatja be:

unsigned int current_word = 0;
_controlfp_s(&current_word, _DN_SAVE, _MCW_DN);
// Denormal values preserved on ARM platforms and on x64 processors with
// SSE2 support. NOP on x86 platforms.
_controlfp_s(&current_word, _DN_FLUSH, _MCW_DN);
// Denormal values flushed to zero by hardware on ARM platforms
// and x64 processors with SSE2 support. Ignored on other x86 platforms.

Ezt a függvényt a rendszer figyelmen kívül hagyja a fordításhoz (/clrCommon Language Runtime-fordítás), mert a közös nyelvi futtatókörnyezet (CLR) csak az alapértelmezett lebegőpontos pontosságot támogatja.

X64 esetén csak az MXCSR-nyilvántartásban tárolt SSE2 vezérlőszavak érintettek. A végtelen mód vagy a lebegőpontos pontosság módosítása nem támogatott. Ha a pontosság-vezérlési maszkot az x64 platformon használják, a függvény érvényesítést ad, és az érvénytelen paraméterkezelő meghívása a paraméterérvényesítésben leírtak szerint történik.

X86 _controlfp_s esetén az x87 és az SSE2 vezérlőszavait is befolyásolja, ha vannak ilyenek. Előfordulhat, hogy a két vezérlőszavak nem összhangban vannak egymással (például egy korábbi hívás __control87_2miatt); ha a két vezérlőszava között ellentmondás van, _controlfp_s akkor a jelölőt a EM_AMBIGUOUS következő értékre állítja currentControl: . Figyelmeztetés, hogy a visszaadott vezérlőszavak nem feltétlenül jelölik pontosan a lebegőpontos vezérlőszavak állapotát.

Ha a maszk nincs megfelelően beállítva, ez a függvény érvénytelen paraméterkivételt hoz létre a paraméterérvényesítésben leírtak szerint. Ha a végrehajtás folytatva van, ez a függvény ad vissza, és a függvényt a értékre EINVALállítja.errnoEINVAL

Alapértelmezés szerint ennek a függvénynek a globális állapota hatóköre az alkalmazásra terjed ki. A viselkedés módosításához tekintse meg a globális állapotot a CRT-ben.

Arm-platformok

• A végtelen mód vagy a lebegőpontos pontosság módosítása nem támogatott. Ha a pontosságvezérlő maszkot az x64-platformon használják, a függvény helyességi műveletet indít el, és a paraméterérvényesítésben leírtak szerint érvénytelen paraméterkezelőt hív meg.
• Az ARM32 (megszűnt) esetén a Windows nem támogatja a FP-kivételek használatát.
• Az ARM64-en az egész _MCW_EM vagy bármely bit maszkolása (_EM_INEXACT, , _EM_UNDERFLOW, _EM_OVERFLOW_EM_ZERODIVIDEés _EM_INVALID) megfelelően módosítsa az FPCR-regisztert. A standard matematikai függvények (például érvénytelen művelet std::acos) által kiváltott lebegőpontos kivételek mentesülnek a viselkedés alól, és az FPCR-regisztrációtól függően figyelmen kívül hagyhatók vagy megfelelően emelhetők. További információkért lásd az ARM32 ABI-konvenciók áttekintését.
• A ARM64EC a Windows elkapja a processzor lebegőpontos kivételeit, és letiltja őket az FPCR-regisztrációban. Ez biztosítja a különböző processzorvariánsok konzisztens viselkedését.

Maszkállandók és értékek

A maszk esetében a _MCW_EM törlés a kivételt állítja be, amely lehetővé teszi a hardveres kivételt; a beállítás elrejti a kivételt. Ha bekövetkezik _EM_UNDERFLOW vagy _EM_OVERFLOW előfordul, a rendszer nem ad ki hardverkivételt a következő lebegőpontos utasítás végrehajtásáig. Ha közvetlenül utána vagy _EM_UNDERFLOWután _EM_OVERFLOW szeretne hardverkivételt létrehozni, hívja meg az utasítástFWAIT MASM.

Maszk	Hexa érték	Állandó	Hexa érték
_MCW_DN (Denormális vezérlő)	0x03000000	_DN_SAVE _DN_FLUSH	0x00000000 0x01000000
_MCW_EM (Kivételmaszk megszakítása)	0x0008001F	_EM_INVALID _EM_DENORMAL _EM_ZERODIVIDE _EM_OVERFLOW _EM_UNDERFLOW _EM_INEXACT	0x00000010 0x00080000 0x00000008 0x00000004 0x00000002 0x00000001
_MCW_IC (Végtelen vezérlőelem) (ARM- vagy x64-platformokon nem támogatott.)	0x00040000	_IC_AFFINE _IC_PROJECTIVE	0x00040000 0x00000000
_MCW_RC (Kerekítés vezérlő)	0x00000300	_RC_CHOP _RC_UP _RC_DOWN _RC_NEAR	0x00000300 0x00000200 0x00000100 0x00000000
_MCW_PC (Pontosság-vezérlés) (ARM- vagy x64-platformokon nem támogatott.)	0x00030000	_PC_24 (24 bit) _PC_53 (53 bit) _PC_64 (64 bit)	0x00020000 0x00010000 0x00000000

Követelmények

Rutin	Kötelező fejléc
_controlfp_s	<float.h>

További kompatibilitási információkért lásd: Kompatibilitás.

példa

// 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 );
}

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

Lásd még

Matematikai és lebegőpontos támogatás
_clear87, _clearfp
_status87, , _statusfp_statusfp2
_control87, , _controlfp__control87_2