Se recomienda usar Visual Studio 2017

_control87, _controlfp, __control87_2

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Obtiene y establece la palabra de control de punto flotante. Una versión más segura de _controlfp está disponible; vea _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  
);  

Parámetros

new
Valores de bit de la nueva palabra de control.

mask
Máscara de los bits de la nueva palabra de control que se va a definir.

x86_cw
Se llena con la palabra de control de la unidad de punto flotante x87. Pase 0 (NULL) para establecer solo la palabra de control de SSE2.

sse2_cw
Palabra de control de la unidad de punto flotante de SSE. Pase 0 (NULL) para establecer solo la palabra de control de x87.

En el caso de _control87 y _controlfp, los bits del valor devuelto indican el estado de control del punto flotante. Para ver una definición completa de los bits que devuelve _control87, vea FLOAT.H.

En el caso de __control87_2, el valor devuelto es 1, que indica que la operación ha sido correcta.

La función _control87 obtiene y establece la palabra de control de punto flotante. La palabra de control de punto flotante permite que el programa cambie los modos de precisión, redondeo e infinito en el paquete matemático de punto flotante, en función de la plataforma. También puede utilizar _control87 para aplicar o quitar una máscara a excepciones de punto flotante. Si el valor de mask es igual a 0, _control87 obtiene la palabra de control de punto flotante. Si mask es distinto de cero, se establece un nuevo valor para la palabra de control: en el caso de cualquier bit que esté activado (es decir, que sea igual a 1) en mask, se usa el bit correspondiente de new para actualizar la palabra de control. In other words, fpcntrl = ((fpcntrl & ~mask) | (new & mask)) donde fpcntrl es la palabra de control de punto flotante.

System_CAPS_ICON_note.jpg Nota

De forma predeterminada, las bibliotecas en tiempo de ejecución aplican máscaras a todas las excepciones de punto flotante.

_controlfp es una versión independiente de la plataforma y portable de _control87. Es casi idéntica a la función _control87 de las plataformas Intel (x86), x64 y ARM. Si tiene como destino las plataformas x86, x64 o ARM, use _control87 o _controlfp.

La diferencia entre _control87 y _controlfp es cómo tratan los valores desnormalizados. En el caso de las plataformas Intel (x86), x64 y ARM, _control87 puede establecer y borrar la máscara de la excepción de operando desnormalizado. _controlfp no modifica la máscara de la excepción de operando desnormalizado. En este ejemplo se muestra la diferencia:

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

Los valores posibles de la constante de máscara (mask) y los nuevos valores de control (new) se muestran en la siguiente tabla de valores hexadecimales. Use las constantes portables que se indican a continuación (_MCW_EM, _EM_INVALID, etc.) como argumentos para estas funciones, en lugar de proporcionar los valores hexadecimales explícitamente.

Las plataformas derivadas de Intel (x86) admiten los valores de entrada y salida desnormalizados en el hardware. El comportamiento de x86 consiste en conservar los valores desnormalizados. La plataforma ARM y las plataformas de x64 compatibles con SSE2 permiten que los operandos y resultados desnormalizados se vacíen, es decir, que se conviertan en cero. Las funciones _controlfp y _control87 proporcionan una máscara para cambiar este comportamiento. En el siguiente ejemplo se muestra la forma de usar esta máscara.

_controlfp(_DN_SAVE, _MCW_DN);     
// Denormal values preserved on ARM platforms and on x64 processors with  
// SSE2 support. NOP on x86 platforms.  
_controlfp(_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.  

En las plataformas ARM, las funciones _control87 y _controlfp se aplican al registro de FPSCR. En arquitecturas de x64, solo se ve afectada la palabra de control de SSE2 almacenada en el registro de MXCSR. En plataformas Intel (x86), _control87 y _controlfp afectan a las palabras de control de x87 y SSE2, si existen. La función __control87_2 permite controlar las unidades de punto flotantes de x87 y SSE2 juntas o por separado. Si desea que se vean afectadas las dos unidades, pase las direcciones de dos enteros a x86_cw y sse2_cw. Si desea que solo se vea afectada una unidad, pase una dirección para ese parámetro y pase 0 para el otro. Si se pasa 0 para uno de estos parámetros, la función no tiene ningún efecto en esa unidad de punto flotante. Esta funcionalidad podría ser útil en situaciones en la que parte del código usa la unidad de punto flotante x87 y otra parte usa la unidad de punto flotante SSE2. Si usa __control87_2 en una parte de un programa y establece valores distintos para las palabras de control de punto flotante, y a continuación usa _control87 o _controlfp para manipular todavía más la palabra de control, quizás _control87 y _controlfp no puedan devolver una sola palabra de control para representar el estado de las dos unidades de punto flotante. En ese caso, estas funciones establecen el indicador EM_AMBIGUOUS en el valor entero devuelto para indicar que hay una incoherencia entre las dos palabras de control. Se trata de una forma de advertir que la palabra de control devuelta podría no representar con precisión el estado de las dos palabras de control de punto flotante.

En las arquitecturas de ARM y x64 no se puede cambiar el modo de infinito ni la precisión de punto flotante. Si se usa la máscara de control de precisión en la x64 plataforma, la función genera una aserción y se invoca el controlador de parámetros no válidos, como se describe en validación del parámetro.

System_CAPS_ICON_note.jpg Nota

__control87_2 no se admite en las arquitecturas ARM ni x64. Si usa __control87_2 y compila el programa para las arquitecturas de ARM o de x64, el compilador genera un error.

Estas funciones se omiten cuando usa /clr (compilación de Common Language Runtime) o /clr:pure para compilar, porque common language runtime (CLR) solo admite la precisión de punto flotante predeterminada.

Valores hexadecimales

En el caso de la máscara _MCW_EM, si se borra la máscara se establece la excepción, con lo que se permite la excepción de hardware. Si se establece la máscara, se oculta la excepción. Si se produce una constante _EM_UNDERFLOW o _EM_OVERFLOW, no se genera ninguna excepción de hardware hasta que se ejecute la instrucción de punto flotante siguiente. Para generar una excepción de hardware inmediatamente después de _EM_UNDERFLOW o _EM_OVERFLOW, llame a la instrucción de MASM FWAIT.

MáscaraValor hexadecimalConstanteValor hexadecimal
_MCW_DN (control desnormalizado)0x03000000_DN_SAVE

 _DN_FLUSH
0x00000000

0x01000000
_MCW_EM (máscara de excepción de interrupción)0x0008001F_EM_INVALID

 _EM_DENORMAL

 _EM_ZERODIVIDE

 _EM_OVERFLOW

 _EM_UNDERFLOW

 _EM_INEXACT
0x00000010

0x00080000

0x00000008

0x00000004

0x00000002

0x00000001
_MCW_IC (control de infinito)

(No se admite en las plataformas ARM o nix64.)
0x00040000_IC_AFFINE

 _IC_PROJECTIVE
0x00040000

0x00000000
_MCW_RC (control de redondeo)0x00000300_RC_CHOP

 _RC_UP

 _RC_DOWN

 _RC_NEAR
0x00000300

0x00000200

0x00000100

0x00000000
_MCW_PC (control de precisión)

(No se admite en las plataformas ARM o nix64.)
0x00030000_PC_24 (24 bits)

 _PC_53(53 bits)

 _PC_64(64 bits)
0x00020000

0x00010000

0x00000000
RutinaEncabezado necesario
_control87, _controlfp, _control87_2<float.h>

Para obtener más información sobre compatibilidad, vea Compatibility.

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

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  

No es aplicable. Para llamar a la función estándar de C, use PInvoke. Para obtener más información, vea Ejemplos de invocación de plataforma.

Compatibilidad de punto flotante
_clear87, _clearfp
_status87, _statusfp, _statusfp2
_controlfp_s

Mostrar: