/fp (Especificar comportamiento de punto flotante)/fp (Specify floating-point behavior)

Especifica cómo el compilador trata las excepciones, optimizaciones y expresiones de punto flotante.Specifies how the compiler treats floating-point expressions, optimizations, and exceptions. Las opciones de /FP especifican si el código generado permite realizar cambios en el entorno de punto flotante en el modo de redondeo, las máscaras de excepción y el comportamiento subnormal, y si las comprobaciones de estado de punto flotante devuelven resultados actuales y precisos.The /fp options specify whether the generated code allows floating-point environment changes to the rounding mode, exception masks, and subnormal behavior, and whether floating-point status checks return current, accurate results. Controla si el compilador genera código que mantiene la operación de origen y el orden de las expresiones, y se ajusta al estándar para la propagación de NaN, o bien, si en su lugar genera código más eficaz que puede reordenar o combinar operaciones y usar la simplificación de las transformaciones algebraicas no permitidas por el estándar.It controls whether the compiler generates code that maintains source operation and expression ordering and conforms to the standard for NaN propagation, or if it instead generates more efficient code that may reorder or combine operations and use simplifying algebraic transformations that are not allowed by the standard.

SintaxisSyntax

/FP:[precisión | estricta | rápida | excepto[ - ]]/fp:[precise | strict | fast | except[-]]

ArgumentosArguments

cifrasprecise

De forma predeterminada, el compilador usa el /fp:precise comportamiento.By default, the compiler uses /fp:precise behavior.

En /fp:precise , el compilador conserva el orden de las expresiones de origen y las propiedades de redondeo del código de punto flotante al generar y optimizar el código de objeto para el equipo de destino.Under /fp:precise the compiler preserves the source expression ordering and rounding properties of floating-point code when it generates and optimizes object code for the target machine. El compilador se redondea a la precisión del código fuente en cuatro puntos específicos durante la evaluación de expresiones: en las asignaciones, en conversiones, cuando se pasa un argumento de punto flotante a una llamada de función, y cuando un valor de punto flotante se devuelve de una llamada de función.The compiler rounds to source code precision at four specific points during expression evaluation: at assignments, at typecasts, when a floating-point argument is passed to a function call, and when a floating-point value is returned from a function call. Los cálculos intermedios se pueden realizar en la precisión de la máquina.Intermediate computations may be performed at machine precision. Conversiones se puede usar para redondear de forma explícita los cálculos intermedios.Typecasts can be used to explicitly round intermediate computations.

El compilador no realiza transformaciones algebraicas en expresiones de punto flotante, como la reasociación o la distribución, a menos que se garantice que la transformación genera un resultado idéntico bit a bit.The compiler does not perform algebraic transformations on floating-point expressions, such as reassociation or distribution, unless the transformation is guaranteed to produce a bitwise identical result. Las expresiones que implican valores especiales (NaN, + infinito,-Infinity,-0,0) se procesan de acuerdo con las especificaciones IEEE-754.Expressions that involve special values (NaN, +infinity, -infinity, -0.0) are processed according to IEEE-754 specifications. Por ejemplo, x != x se evalúa como true si x es Nan.For example, x != x evaluates to true if x is NaN. Los contratosde punto flotante, es decir, las instrucciones máquina que combinan las operaciones de punto flotante, se pueden generar en /fp:precise .Floating-point contractions, that is, machine instructions that combine floating-point operations, may be generated under /fp:precise.

El compilador genera código diseñado para ejecutarse en el entorno de punto flotante predeterminado y da por supuesto que no se tiene acceso al entorno de punto flotante ni se modifica en tiempo de ejecución.The compiler generates code intended to run in the default floating-point environment and assumes that the floating-point environment is not accessed or modified at runtime. Es decir, se supone que el código no desenmascara las excepciones de punto flotante, los registros de estado de punto flotante de lectura o escritura o los modos de redondeo.That is, it assumes that the code does not unmask floating-point exceptions, read or write floating-point status registers, or change rounding modes.

Si el código de punto flotante no depende del orden de las operaciones y expresiones en las instrucciones de punto flotante (por ejemplo, si no le importa si a * b + a * c se calcula como (b + c) * a o 2 * a como a + a ), tenga en cuenta la opción /FP: Fast , que puede generar código más rápido y eficaz.If your floating-point code does not depend on the order of operations and expressions in your floating-point statements (for example, if you don't care whether a * b + a * c is computed as (b + c) * a or 2 * a as a + a), consider the /fp:fast option, which can produce faster, more efficient code. Si el código depende del orden de las operaciones y de las expresiones, y obtiene acceso o modifica el entorno de punto flotante (por ejemplo, para cambiar los modos de redondeo o para interceptar las excepciones de punto flotante), use /FP: STRICT.If your code both depends on the order of operations and expressions, and accesses or alters the floating-point environment (for example, to change rounding modes or to trap floating-point exceptions), use /fp:strict.

strictstrict

/fp:strict tiene un comportamiento similar a /fp:precise , es decir, el compilador conserva las propiedades de ordenación de origen y redondeo del código de punto flotante al generar y optimizar el código de objeto para el equipo de destino, y observa el estándar al controlar los valores especiales./fp:strict has behavior similar to /fp:precise, that is, the compiler preserves the source ordering and rounding properties of floating-point code when it generates and optimizes object code for the target machine, and observes the standard when handling special values. Además, el programa puede tener acceso o modificar de forma segura el entorno de punto flotante en tiempo de ejecución.In addition, the program may safely access or modify the floating-point environment at runtime.

En /fp:strict , el compilador genera código que permite al programa desenmascarar de forma segura las excepciones de punto flotante, leer o escribir registros de estado de punto flotante o cambiar los modos de redondeo.Under /fp:strict, the compiler generates code that allows the program to safely unmask floating-point exceptions, read or write floating-point status registers, or change rounding modes. Se redondea a la precisión del código fuente en cuatro puntos específicos durante la evaluación de expresiones: en las asignaciones, en conversiones, cuando se pasa un argumento de punto flotante a una llamada de función, y cuando un valor de punto flotante se devuelve de una llamada de función.It rounds to source code precision at four specific points during expression evaluation: at assignments, at typecasts, when a floating-point argument is passed to a function call, and when a floating-point value is returned from a function call. Los cálculos intermedios se pueden realizar en la precisión de la máquina.Intermediate computations may be performed at machine precision. Conversiones se puede usar para redondear de forma explícita los cálculos intermedios.Typecasts can be used to explicitly round intermediate computations. El compilador no realiza transformaciones algebraicas en expresiones de punto flotante, como la reasociación o la distribución, a menos que se garantice que la transformación genera un resultado idéntico bit a bit.The compiler does not perform algebraic transformations on floating-point expressions, such as reassociation or distribution, unless the transformation is guaranteed to produce a bitwise identical result. Las expresiones que implican valores especiales (NaN, + infinito,-Infinity,-0,0) se procesan de acuerdo con las especificaciones IEEE-754.Expressions that involve special values (NaN, +infinity, -infinity, -0.0) are processed according to IEEE-754 specifications. Por ejemplo, x != x se evalúa como true si x es Nan.For example, x != x evaluates to true if x is NaN. Los contratos de punto flotante no se generan en /fp:strict .Floating-point contractions are not generated under /fp:strict.

/fp:strict es computacionalmente más caro que /fp:precise porque el compilador debe insertar instrucciones adicionales para interceptar excepciones y permitir que los programas tengan acceso o modifiquen el entorno de punto flotante en tiempo de ejecución./fp:strict is computationally more expensive than /fp:precise because the compiler must insert additional instructions to trap exceptions and allow programs to access or modify the floating-point environment at runtime. Si el código no usa esta capacidad, pero requiere la ordenación y el redondeo del código fuente, o si se basa en valores especiales, use /fp:precise .If your code doesn't use this capability, but requires source code ordering and rounding, or relies on special values, use /fp:precise. En caso contrario, considere la posibilidad de usar /fp:fast , que puede generar código más rápido y más pequeño.Otherwise, consider using /fp:fast, which can produce faster and smaller code.

fastfast

La /fp:fast opción permite al compilador reordenar, combinar o simplificar las operaciones de punto flotante para optimizar el código de punto flotante para la velocidad y el espacio.The /fp:fast option allows the compiler to reorder, combine, or simplify floating-point operations to optimize floating-point code for speed and space. El compilador puede omitir el redondeo en instrucciones de asignación, conversiones o llamadas de función.The compiler may omit rounding at assignment statements, typecasts, or function calls. Puede reordenar las operaciones o realizar transformaciones algebraicas, por ejemplo, mediante el uso de las leyes asociativas y distributivo, aunque dichas transformaciones tengan como resultado un comportamiento de redondeo perceptiblemente diferente.It may reorder operations or perform algebraic transforms, for example, by use of associative and distributive laws, even if such transformations result in observably different rounding behavior. Debido a esta optimización mejorada, el resultado de algunos cálculos de punto flotante puede diferir de los producidos por otras /fp Opciones.Because of this enhanced optimization, the result of some floating-point computations may differ from those produced by other /fp options. Es posible que los valores especiales (NaN, + infinito,-Infinity,-0,0) no se propaguen o se comporten de forma estricta según el estándar IEEE-754.Special values (NaN, +infinity, -infinity, -0.0) may not be propagated or behave strictly according to the IEEE-754 standard. Los contratos de punto flotante se pueden generar en /fp:fast .Floating-point contractions may be generated under /fp:fast. El compilador sigue estando enlazado por la arquitectura subyacente en y las /fp:fast optimizaciones adicionales pueden estar disponibles mediante el uso de la opción /Arch .The compiler is still bound by the underlying architecture under /fp:fast, and additional optimizations may be available through use of the /arch option.

En /fp:fast , el compilador genera código diseñado para ejecutarse en el entorno de punto flotante predeterminado y da por supuesto que no se tiene acceso al entorno de punto flotante ni se ha modificado en tiempo de ejecución.Under /fp:fast, the compiler generates code intended to run in the default floating-point environment and assumes that the floating-point environment isn't accessed or modified at runtime. Es decir, se supone que el código no desenmascara las excepciones de punto flotante, los registros de estado de punto flotante de lectura o escritura o los modos de redondeo.That is, it assumes that the code does not unmask floating-point exceptions, read or write floating-point status registers, or change rounding modes.

/fp:fast está diseñado para programas que no requieren la ordenación estricta de código fuente y el redondeo de expresiones de punto flotante, y no se basan en las reglas estándar para controlar valores especiales como NaN./fp:fast is intended for programs that do not require strict source code ordering and rounding of floating-point expressions, and do not rely on the standard rules for handling special values such as NaN. Si el código de punto flotante requiere la preservación de la ordenación y el redondeo del código fuente, o se basa en el comportamiento estándar de los valores especiales, use /FP: precise.If your floating-point code requires preservation of source code ordering and rounding, or relies on standard behavior of special values, use /fp:precise. Si el código tiene acceso al entorno de punto flotante o lo modifica para cambiar los modos de redondeo, desenmascarar las excepciones de punto flotante o comprobar el estado de punto flotante, use /FP: STRICT.If your code accesses or modifies the floating-point environment to change rounding modes, unmask floating-point exceptions, or check floating-point status, use /fp:strict.

CEPTexcept

La /fp:except opción genera código para garantizar que todas las excepciones de punto flotante sin máscara se desencadenen en el punto exacto en el que se producen y que no se genera ninguna excepción de punto flotante adicional.The /fp:except option generates code to ensures that any unmasked floating-point exceptions are raised at the exact point at which they occur, and that no additional floating-point exceptions are raised. De forma predeterminada, la /fp:strict opción habilita /fp:except , y no /fp:precise .By default, the /fp:strict option enables /fp:except, and /fp:precise does not. La /fp:except opción no es compatible con /fp:fast .The /fp:except option is not compatible with /fp:fast. La opción se puede deshabilitar explícitamente en /fp:except- .The option can be explicitly disabled by us of /fp:except-.

Tenga en cuenta que no /fp:except habilita ninguna excepción de punto flotante por sí misma, pero es necesaria para que los programas habiliten las excepciones de punto flotante.Note that /fp:except does not enable any floating-point exceptions by itself, but it is required for programs to enable floating-point exceptions. Consulte _controlfp para obtener información sobre cómo habilitar las excepciones de punto flotante.See _controlfp for information on how to enable floating-point exceptions.

ObservacionesRemarks

/fpSe pueden especificar varias opciones en la misma línea de comandos del compilador.Multiple /fp options can be specified in the same compiler command line. Solo una de /fp:strict /fp:fast /fp:precise las opciones, y puede estar en vigor al mismo tiempo.Only one of /fp:strict, /fp:fast, and /fp:precise options can be in effect at a time. Si se especifica más de una de estas opciones en la línea de comandos, la opción más adelante tendrá prioridad y el compilador generará una advertencia.If more than one of these options is specified on the command line, the later option takes precedence and the compiler generates a warning. Las /fp:strict /fp:except Opciones y no son compatibles con /clr .The /fp:strict and /fp:except options are not compatible with /clr.

La opción /za (compatibilidad con ANSI) no es compatible con /fp .The /Za (ANSI compatibility) option is not compatible with /fp.

Usar directivas de compilador para controlar el comportamiento de punto flotanteUsing Compiler Directives to Control Floating-Point Behavior

El compilador proporciona tres directivas pragma para invalidar el comportamiento de punto flotante especificado en la línea de comandos: float_control, fenv_accessy fp_contract.The compiler provides three pragma directives to override the floating-point behavior specified on the command-line: float_control, fenv_access, and fp_contract. Puede usar estas directivas para controlar el comportamiento de punto flotante en el nivel de función, no dentro de una función.You can use these directives to control floating-point behavior at function-level, not within a function. Tenga en cuenta que estas directivas no se corresponden directamente con las /fp Opciones.Note that these directives do not correspond directly to the /fp options. En esta tabla se muestra cómo /fp se asignan entre sí las directivas Options y pragma.This table shows how the /fp options and pragma directives map to each other. Para obtener más información, vea la documentación de las opciones individuales y las directivas pragma.For more information, see the documentation for the individual options and pragma directives.

OpciónOption float_control (preciso)float_control(precise) float_control (excepto)float_control(except) fenv_accessfenv_access fp_contractfp_contract
/fp:fast apagadooff apagadooff apagadooff onon
/fp:precise enon apagadooff apagadooff onon
/fp:strict onon onon enon apagadooff

El entorno de punto flotante predeterminadoThe default floating point environment

Cuando se inicializa un proceso, se establece el entorno de punto flotante predeterminado .When a process is initialized, the default floating point environment is set. Este entorno enmascara todas las excepciones de punto flotante, establece el modo de redondeo en redondear a más próximo ( FE_TONEAREST ), conserva los valores subnormales (desnormalizados), usa la precisión predeterminada de mantisa (mantisa) para float double los valores de, y long double , y si es compatible, establece el control de infinito en el modo de afinidad predeterminado.This environment masks all floating point exceptions, sets the rounding mode to round to nearest (FE_TONEAREST), preserves subnormal (denormal) values, uses the default precision of significand (mantissa) for float, double, and long double values, and where supported, sets the infinity control to the default affine mode.

Acceso y modificación del entorno de punto flotanteFloating-point environment access and modification

El tiempo de ejecución de Microsoft Visual C++ proporciona varias funciones para tener acceso al entorno de punto flotante y modificarlo.The Microsoft Visual C++ runtime provides several functions to access and modify the floating-point environment. Entre ellas se incluyen _controlfp, _clearfpy _statusfp y sus variantes.These include _controlfp, _clearfp, and _statusfp and their variants. Para garantizar el comportamiento correcto del programa cuando el código tiene acceso al entorno de punto flotante o lo modifica, fenv_access debe estar habilitado, ya sea mediante la /fp:strict opción o mediante el uso de la fenv_access Directiva pragma, para que estas funciones surtan efecto.To ensure correct program behavior when your code accesses or modifies the floating-point environment, fenv_access must be enabled, either by the /fp:strict option or by use of the fenv_access pragma, for these functions to have any effect. Cuando fenv_access no está habilitado, el acceso o la modificación del entorno de punto flotante puede dar lugar a un comportamiento inesperado del programa: es posible que el código no respete los cambios solicitados en el entorno de punto flotante; puede que los registros de estado de punto flotante no informen de los resultados esperados o actuales, y que se produzcan excepciones de punto flotante inesperadas.When fenv_access is not enabled, access or modification of the floating-point environment may result in unexpected program behavior: code may not honor requested changes to the floating-point environment; the floating-point status registers may not report expected or current results; and unexpected floating-point exceptions may occur or expected floating-point exceptions may not occur.

Cuando el código tenga acceso al entorno de punto flotante o lo modifique, debe tener cuidado al combinar el código donde fenv_access está habilitado con código que no tiene fenv_access habilitado.When your code accesses or modifies the floating-point environment, you must be careful when you combine code where fenv_access is enabled with code that does not have fenv_access enabled. En el código donde fenv_access no está habilitado, el compilador supone que el entorno de punto flotante predeterminado de la plataforma está en vigor y que el estado de punto flotante no es accesible ni modificado.In code where fenv_access is not enabled, the compiler assumes that the platform default floating-point environment is in effect, and that the floating-point status is not accessed or modified. Se recomienda guardar y restaurar el entorno de punto flotante local a su estado predeterminado antes de que el control se transfiera a una función que no tenga fenv_access habilitada.We recommend you save and restore the local floating-point environment to its default state before control is transferred to a function that does not have fenv_access enabled. En este ejemplo se muestra cómo float_control se puede establecer y restaurar la Directiva pragma:This example demonstrates how the float_control pragma can be set and restored:

#pragma float_control(strict, on, push)
// Code that uses /fp:strict mode
#pragma float_control(pop)

Modos de redondeo de punto flotanteFloating-point rounding modes

En /fp:precise y, /fp:fast el compilador genera código diseñado para ejecutarse en el entorno de punto flotante predeterminado y presupone que no se tiene acceso al entorno ni se ha modificado en tiempo de ejecución.Under both /fp:precise and /fp:fast the compiler generates code intended to run in the default floating-point environment and assumes that the environment isn't accessed or modified at runtime. Es decir, se supone que el código no desenmascara las excepciones de punto flotante, los registros de estado de punto flotante de lectura o escritura o los modos de redondeo.That is, it assumes that the code does not unmask floating-point exceptions, read or write floating-point status registers, or change rounding modes. Sin embargo, algunos programas deben modificar el entorno de punto flotante.However, some programs need to alter the floating-point environment. Por ejemplo, en este ejemplo se calculan los límites de error de una multiplicación de punto flotante mediante la modificación de los modos de redondeo de punto flotante:For example, this sample computes error bounds of a floating-point multiplication by altering floating-point rounding modes:

// fp_error_bounds.cpp
#include <iostream>
#include <limits>
using namespace std;

int main(void)
{
    float a = std::<float>::max();
    float b = -1.1;
    float cLower = 0.0;
    float cUpper = 0.0;
    unsigned int control_word = 0;
    int err = 0;

    // compute lower error bound.
    // set rounding mode to -infinity.
    err = _controlfp_s(&control_word, _RC_DOWN, _MCW_RC);
    if (err)
    {
        cout << "_controlfp_s(&control_word, _RC_DOWN, _MCW_RC) failed with error:" << err << endl;
    }  
    cLower = a * b;

    // compute upper error bound.
    // set rounding mode to +infinity.
    err = _controlfp_s(&control_word, _RC_UP, _MCW_RC);
    if (err)
    {
        cout << "_controlfp_s(&control_word, _RC_UP, _MCW_RC) failed with error:" << err << endl;
    }
    cUpper = a * b;

    // restore default rounding mode.
    err = _controlfp_s(&control_word, _CW_DEFAULT, _MCW_RC);
    if (err)
    {
        cout << "_controlfp_s(&control_word, _CW_DEFAULT, _MCW_RC) failed with error:" << err << endl;
    }
    // display error bounds.
    cout << "cLower = " << cLower << endl;
    cout << "cUpper = " << cUpper << endl;
    return 0;
}

Dado que el compilador asume el entorno de punto flotante predeterminado en /fp:fast y /fp:precise es libre de omitir las llamadas a _controlfp_s . Por ejemplo, cuando se compila con /O2 y /fp:precise para la arquitectura x86, los límites no se calculan y el programa de ejemplo genera:For example, when compiled by using both /O2 and /fp:precise for the x86 architecture, the bounds are not computed, and the sample program outputs:

cLower = -inf
cUpper = -inf

Cuando se compila con /O2 y /fp:strict para la arquitectura x86, el programa de ejemplo genera:When compiled with both /O2 and /fp:strict for the x86 architecture, the sample program outputs:

cLower = -inf
cUpper = -3.40282e+38

Valores especiales de punto flotanteFloating-point special values

En /fp:precise y /fp:strict , las expresiones que implican valores especiales (Nan, + infinito,-Infinity,-0,0) se comportan de acuerdo con las especificaciones IEEE-754.Under /fp:precise and /fp:strict, expressions that involve special values (NaN, +infinity, -infinity, -0.0) behave according to the IEEE-754 specifications. En /fp:fast , el comportamiento de estos valores especiales puede ser incoherente con IEEE-754.Under /fp:fast, the behavior of these special values may be inconsistent with IEEE-754.

Este ejemplo muestra el comportamiento diferente de los valores especiales /fp:precise en /fp:strict y /fp:fast :This sample demonstrates the different behavior of special values under /fp:precise, /fp:strict and /fp:fast:

// fp_special_values.cpp
#include <stdio.h>
#include <cmath>

float gf0 = -0.0;

int main()
{
    float f1 = INFINITY;
    float f2 = NAN;
    float f3 = -INFINITY;
    bool a, b;
    float c, d, e;
    a = (f1 == f1);
    b = (f2 == f2);
    c = (f1 - f1);
    d = (f2 - f2);
    printf("INFINITY == INFINITY : %d\n", a);
    printf("NAN == NAN           : %d\n", b);
    printf("INFINITY - INFINITY  : %f\n", c);
    printf("NAN - NAN            : %f\n", d);

    e = gf0 / abs(f3);
    printf("std::signbit(-0.0/-INFINITY): %d\n", std::signbit(c));
    return 0;
}

Cuando se compila con /O2 /fp:precise o /O2 /fp:strict para la arquitectura x86, las salidas son coherentes con la especificación IEEE-754:When compiled with /O2 /fp:precise or /O2 /fp:strict for x86 architecture, the outputs are consistent with the IEEE-754 specification:

INFINITY == INFINITY : 1
NAN == NAN           : 0
INFINITY - INFINITY  : -nan(ind)
NAN - NAN            : -nan(ind)
std::signbit(-0.0/-INFINITY): 1

Cuando se compila con /O2 /fp:fast para la arquitectura x86, las salidas no son coherentes con IEEE-754:When compiled with /O2 /fp:fast for x86 architecture, the outputs are not consistent with IEEE-754:

INFINITY == INFINITY : 1
NAN == NAN           : 1
INFINITY - INFINITY  : 0.000000
NAN - NAN            : 0.000000
std::signbit(-0.0/-INFINITY): 0

Transformaciones algebraicos de punto flotanteFloating-point algebraic transformations

En /fp:precise y /fp:strict , el compilador no realiza transformaciones matemáticas a menos que se garantice que la transformación genera un resultado idéntico bit a bit.Under /fp:precise and /fp:strict, the compiler does not perform mathematical transformations unless the transformation is guaranteed to produce a bitwise identical result. El compilador puede realizar dichas transformaciones en /fp:fast .The compiler may perform such transformations under /fp:fast. Por ejemplo, la expresión a * b + a * c de la función de ejemplo algebraic_transformation se puede compilar en a * (b + c) en /fp:fast .For example, the expression a * b + a * c in the sample function algebraic_transformation may be compiled into a * (b + c) under /fp:fast. Dichas transformaciones no se realizan en /fp:precise o /fp:strict , y el compilador genera a * b + a * c .Such transformations aren't performed under /fp:precise or /fp:strict, and the compiler generates a * b + a * c.

float algebraic_transformation (float a, float b, float c)
{
    return a * b + a * c;
}

Puntos de conversión explícitos de punto flotanteFloating-point explicit casting points

En /fp:precise y /fp:strict , el compilador se redondea a la precisión del código fuente en cuatro puntos específicos durante la evaluación de expresiones: en las asignaciones, en conversiones, cuando se pasa un argumento de punto flotante a una llamada de función, y cuando un valor de punto flotante se devuelve de una llamada de función.Under /fp:precise and /fp:strict, the compiler rounds to source code precision at four specific points during expression evaluation: at assignments, at typecasts, when a floating-point argument is passed to a function call, and when a floating-point value is returned from a function call. Conversiones se puede usar para redondear de forma explícita los cálculos intermedios.Typecasts can be used to explicitly round intermediate computations. En /fp:fast , el compilador no genera conversiones explícitas en estos puntos para garantizar la precisión del código fuente.Under /fp:fast, the compiler does not generate explicit casts at these points to guarantee source code precision. Este ejemplo muestra el comportamiento en diferentes /fp Opciones:This sample demonstrates the behavior under different /fp options:

float casting(float a, float b)
{
    return 5.0*((double)(a+b));
}

Cuando se compila con /O2 /fp:precise o /O2 /fp:strict , puede ver que las conversiones de tipos explícitas se insertan en la conversión y en el punto de retorno de la función en el código generado para la arquitectura x64:When compiled by using /O2 /fp:precise or /O2 /fp:strict, you can see that explicit type casts are inserted at both the typecast and at the function return point in the generated code for the x64 architecture:

        addss    xmm0, xmm1
        cvtss2sd xmm0, xmm0
        mulsd    xmm0, QWORD PTR __real@4014000000000000
        cvtsd2ss xmm0, xmm0
        ret      0

En /O2 /fp:fast el código generado se simplifica, ya que todas las conversiones de tipo están optimizadas:Under /O2 /fp:fast the generated code is simplified, because all type casts are optimized away:

        addss    xmm0, xmm1
        mulss    xmm0, DWORD PTR __real@40a00000
        ret      0

Para establecer esta opción del compilador en el entorno de desarrollo de Visual StudioTo set this compiler option in the Visual Studio development environment

  1. Abra el cuadro de diálogo Páginas de propiedades del proyecto.Open the project's Property Pages dialog box. Para más información, vea Establecimiento del compilador de C++ y de propiedades de compilación en Visual Studio.For details, see Set C++ compiler and build properties in Visual Studio.

  2. Seleccione la Configuration Propertiespágina de propiedades de generación de código de > C/C++ ypropiedades de configuración > Code Generation .Select the Configuration Properties > C/C++ > Code Generation property page.

  3. Modifique la propiedad modelo de punto flotante .Modify the Floating Point Model property.

Para establecer esta opción del compilador mediante programaciónTo set this compiler option programmatically

Consulte tambiénSee also

Opciones del compilador de MSVCMSVC Compiler Options
Sintaxis de línea de comandos del compilador MSVCMSVC Compiler Command-Line Syntax