_control87, _controlfp, __control87_2
Ottiene e imposta la parola di controllo a virgola mobile.È disponibile una versione più sicura di _controlfp; vedere _controlfp_s.
unsigned int _control87(
unsigned int new,
unsigned int mask
);
unsigned int _controlfp(
unsigned int new,
unsigned int mask
);
int __control87_2(
unsigned int new,
unsigned int mask,
unsigned int* x86_cw,
unsigned int* sse2_cw
);
Parametri
new
Nuovi valori di bit di parola di controllo.mask
Maschera da impostare per i nuovi bit di parola di controllo.x86_cw
Compilato con la parola di controllo dell'unità a virgola mobile x87.Passare 0 (NULL) per impostare solo la parola di controllo SSE2.sse2_cw
Parola di controllo dell'unità a virgola mobile SSE.Passare 0 (NULL) per impostare solo la parola di controllo x87.
Valore restituito
Per _control87 e _controlfp, i bit nel valore restituito indicano lo stato del controllo a virgola mobile.Per una definizione completa dei bit restituiti da _control87, vedere FLOAT.H.
Per __control87_2, il valore restituito è 1, che indica un esito positivo.
Note
La funzione _control87 ottiene e imposta la parola di controllo a virgola mobile.La parola di controllo a virgola mobile consente al programma di modificare la precisione, l'arrotondamento, e le modalità di infinito nel pacchetto matematica a virgola mobile.È inoltre possibile mascherare o smascherare eccezioni di virgola mobile utilizzando _control87.Se il valore di mask è uguale a 0, _control87 otterrà la parola di controllo a virgola mobile.Se mask è diverso da zero, viene impostato un nuovo valore per la parola di controllo: Per ogni bit attivo (uguale a 1) in mask, il corrispondente bit in new viene utilizzato per aggiornare la parola di controllo.Ovvero, fpcntrl= ((fpcntrl& ~mask) | (new & mask)) dove fpcntrl è la parola di controllo a virgola mobile.
[!NOTA]
Le librerie di runtime mascherano per impostazione predefinita tutte le eccezioni a virgola mobile.
_controlfp è una versione indipendente dalla piattaforma e portabile di _control87.È quasi identica alla funzione _control87 delle piattaforme Intel (x86) ed è supportata dalle piattaforme MIPS e ALPHA.Per assicurarsi che il codice a virgola mobile sia portabile in MIPS o ALPHA, utilizzare _controlfp.Se le destinazioni sono le piattaforme x86, utilizzare _control87 o _controlfp.
La differenza tra _control87 e _controlfp è il modo in cui queste due funzioni gestiscono i valori NON NORMALI.Per le piattaforme Intel (x86), _control87 può impostare e rimuovere la maschera dell'eccezione OPERANDO NON NORMALE.Le piattaforme ALPHA non supportano questa eccezione, e _controlfp non modifica la maschera dell'eccezione OPERANDO NON NORMALE.Nell'esempio seguente viene illustrata la differenza:
_control87( _EM_INVALID, _MCW_EM );
// DENORMAL is unmasked by this call
_controlfp( _EM_INVALID, _MCW_EM );
// DENORMAL exception mask remains unchanged
I valori possibili per la costante della maschera (mask) e i nuovi valori del controllo (new) sono riportati nella seguente tabella di valori esadecimali.Utilizzare le costanti portabili elencate di seguito (_MCW_EM, _EM_INVALID, e così via) come argomenti per queste funzioni, invece di fornire i valori esadecimali in modo esplicito.
Le piattaforme ALPHA supportano valori di input e output NON NORMALI nel software.Il comportamento predefinito di Windows NT su queste piattaforme è di cancellare a zero i valori NON NORMALI di input e output._controlfp fornisce una nuova maschera per mantenere e cancellare i valori NON NORMALI di input e output.
Le piattaforme Intel (x86) supportano i valori NON NORMALI di input e output a livello di hardware.Il comportamento prevede di mantenere i valori NON NORMALI._control87 non fornisce una maschera per modificare questo comportamento.Nell'esempio seguente viene illustrata questa differenza:
_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 and x86
// processors with SSE2 support. Ignored on other x86 platforms.
Sia _control87 che _controlfp influiscono sulle parole di controllo sia di x87 che di SSE2, se presente.La funzione __control87_2 consente che sia le unità in virgola mobile x87 e che le unità in virgola mobile SSE2 siano controllate insieme o separatamente.Se si desidera modificare entrambe le unità, passare gli indirizzi di due numeri interi a x86_cw e a sse2_cw.Se si desidera modificare solo un'unità, passare un indirizzo per tale parametro ma passare 0 (NULL) per l'altro.Se viene passato 0 per uno di questi parametri, la funzione non ha alcun effetto su quell'unità a virgola mobile.Questa funzionalità può essere utile nelle situazioni in cui una parte del codice utilizza l'unità a virgola mobile x87 e un'altra parte del codice utilizza l'unità a virgola mobile SSE2.Se si utilizza __control87_2 in una parte del programma e si impostano valori diversi per le parole di controllo a virgola mobile, e quindi si utilizza _control87 o _controlfp per modificare ulteriormente la parola di controllo, allora _control87 e _controlfp potrebbero non essere in grado di restituire una singola parola di controllo per rappresentare lo stato di entrambe le unità a virgola mobile.In questo caso, queste funzioni impostano il flag EM_AMBIGUOUS del valore intero restituito per indicare che c'è un'incoerenza tra le due parole di controllo.Si tratta di un avviso relativo al fatto che la parola di controllo restituita potrebbe non rappresentare con precisione lo stato di entrambe le parole di controllo a virgola mobile.
Nell'architettura x64, la modifica alla precisione di virgola mobile non è supportata.Se la maschera del controllo di precisione viene utilizzata sulla piattaforma, un'asserzione e il gestore di parametro non valido vengono richiamati, come descritto in Convalida dei parametri.
[!NOTA]
__control87_2 non è supportato nell'architettura x64.Se si utilizza __control87_2 e si compila il programma per l'architettura x64, il compilatore genera un errore.
Queste funzioni sono deprecate durante la compilazione con /clr (Compilazione Common Language Runtime) o /clr:pure poiché il common language runtime supporta solamente la precisione a virgola mobile predefinita.
Valori esadecimali
Per la maschera _MCW_EM, la cancellazione della maschera imposta l'eccezione, che abilita l'eccezione hardware, l'impostazione della maschera nasconde l'eccezione.Si noti che se si verifica _EM_UNDERFLOW o _EM_OVERFLOW, non viene generata nessuna eccezione hardware fino all'esecuzione della prossima istruzione a virgola mobile.Per generare un'eccezione hardware subito dopo _EM_UNDERFLOW o _EM_OVERFLOW, chiamare l'istruzione FWAIT MASM.
Maschera |
Valore esadecimale |
Costante |
Valore esadecimale |
|---|---|---|---|
_MCW_DN (Controllo non normale) |
0x03000000 |
_DN_SAVE _DN_FLUSH |
0x00000000 0x01000000 |
_MCW_EM (Maschera dell'eccezione di interruzione) |
0x0008001F |
_EM_INVALID _EM_DENORMAL _EM_ZERODIVIDE _EM_OVERFLOW _EM_UNDERFLOW _EM_INEXACT |
0x00000010 0x00080000 0x00000008 0x00000004 0x00000002 0x00000001 |
_MCW_IC (Controllo dell'infinito) |
0x00040000 |
_IC_AFFINE _IC_PROJECTIVE |
0x00040000 0x00000000 |
_MCW_RC (Controllo di arrotondamento) |
0x00000300 |
_RC_CHOP _RC_UP _RC_DOWN _RC_NEAR |
0x00000300 0x00000200 0x00000100 0x00000000 |
_MCW_PC (Controllo di precisione) |
0x00030000 |
_PC_24 (24 bit) _PC_53 (53 bit) _PC_64 (64 bit) |
0x00020000 0x00010000 0x00000000 |
Requisiti
Routine |
Intestazione obbligatoria |
|---|---|
_control87, _controlfp, _control87_2 |
<float.h> |
Per ulteriori informazioni sulla compatibilità, vedere Compatibilità nell'introduzione.
Esempio
// crt_cntrl87.c
// processor: x86
// This program uses __control87_2 to output the x87 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_x87;
// Show original x87 control word and do calculation.
control_word_x87 = __control87_2(0, 0,
&control_word_x87, 0);
printf( "Original: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
// Set precision to 24 bits and recalculate.
control_word_x87 = __control87_2(_PC_24, MCW_PC,
&control_word_x87, 0);
printf( "24-bit: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
// Restore default precision-control bits and recalculate.
control_word_x87 = __control87_2( _CW_DEFAULT, MCW_PC,
&control_word_x87, 0 );
printf( "Default: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
}
Output
Original: 0x0001
0.1 * 0.1 = 1.000000000000000e-002
24-bit: 0x0001
0.1 * 0.1 = 9.999999776482582e-003
Default: 0x0001
0.1 * 0.1 = 1.000000000000000e-002
Equivalente .NET Framework
Non applicabile. Per chiamare la funzione standard C, utilizzare PInvoke. Per ulteriori informazioni, vedere Esempi di PInvoke.