c++ - doble como verdadero/falso

sign c++

Question

Bjarne sugiere usar la condición en if''s como restricción de alcance. En particular este ejemplo.

if ( double d = fd()  ) {
   // d in scope here...
}

Soy curioso cómo interpretar la declaración en un sentido verdadero / falso.

1. Es una declaración
2. Es un doble.

Editar: está en 6.3.2.1 El lenguaje de programación C ++ como una recomendación.

Edit2: templatetypedefs sugerencia de punteros, en particular con moldes dinámicos, podría dar una idea de la sugerencia de Bjarnes.

SteveJessop me dice: - Una condición no es una expresión, también puede ser una declaración, el valor utilizado, es el valor que se evalúa.

Answer 1

En el ejemplo que da Stroustrup, el código en el bloque if divide un valor por d :

if (double d = prim(true)) {
    left /= d;
    break;
}

La división por 0 es un comportamiento indefinido, por lo que tiene sentido en este caso probar d frente al valor de 0.0 antes de dividir. Poner la definición en la condición es una manera conveniente de hacer esto, por las razones que Stroustrup afirma.

Su código no da ninguna razón por la que el valor 0.0 sea ​​especial, y por lo tanto no está claro por qué alguien combinaría la definición de d con esa prueba. Solo use el patrón de Stroustrup cuando los valores "falsos" del tipo que está definiendo necesiten ser tratados especialmente. De lo contrario, simplemente haz esto:

{
    double d = fd();
    // d in scope here...
}

Answer 2

Es a la vez una declaración y un doble. Esto es bastante equivalente a

{
    double d = fd();
    if (d) {
    }
}

Sin embargo, este patrón vale la pena la pequeña sintaxis adicional para simplificar, ya que es bastante útil y común. Además, la transformación es menos obvia una vez que comienzas a agregar cláusulas else, ya que d está fuera del alcance para ellas.

Además, como han señalado otros, es útil en general, pero los tipos de PF en específico tienen algunos problemas en comparación con 0.

Answer 3

la instrucción if basa en el valor asignado a la variable en la expresión de asignación. Si el doble se evalúa a cualquier cosa menos a 0.0, ejecutará el código dentro.

Tenga en cuenta que no debe comparar dobles con cero, pero generalmente funciona según mi experiencia.

Básicamente, no deberías hacer esto.

Los otros contribuidores a este tema han encontrado que esta expresión se usa para excluir el caso cero a fin de evitar una división por cero. Eso es definitivamente inteligente y tal situación legitima este uso en lo que a mí respecta (pero considere la confusión que tal código puede causar).

Answer 4

El código que está viendo es una técnica especializada para declarar variables en sentencias if . Por lo general, ves algo como esto:

if (T* ptr = function()) {
    /* ptr is non-NULL, do something with it here */
} else {
    /* ptr is NULL, and moreover is out of scope and can''t be used here. */
}

Un caso particularmente común es el uso de dynamic_cast aquí:

if (Derived* dPtr = dynamic_cast<Derived*>(basePtr)) {
     /* basePtr really points at a Derived, so use dPtr as a pointer to it. */
} else {
     /* basePtr doesn''t point at a Derived, but we can''t use dPtr here anyway. */
}

Lo que está sucediendo en su caso es que está declarando un double dentro de la declaración if . C ++ interpreta automáticamente cualquier valor distinto de cero como true y cualquier valor cero como false . Lo que significa este código es "declarar d y establecerlo igual a fd() . Si no es cero, entonces ejecuta la instrucción if ".

Dicho esto, esta es una muy mala idea porque las double están sujetas a todo tipo de errores de redondeo que impiden que sean 0 en la mayoría de los casos. Es casi seguro que este código ejecutará el cuerpo de la sentencia if menos que la function se comporte muy bien.

¡Espero que esto ayude!