¿Por qué hay una advertencia de rendimiento en el puntero de conversión a bool?

Question 1

Esta pregunta se extiende ¿Por qué usar !! al convertir int a bool?.

Pensé que estaba siendo genial cuando hice algo como:

bool hasParent() {
    return this->parentNode;
}

Dónde this->parentNode es NULL cuando no hay un nodo principal.

Pero estoy recibiendo:

advertencia C4800: ‘Nodo *’: valor forzado a bool ‘verdadero’ o ‘falso’ (advertencia de rendimiento)

Incluso con un lanzamiento (bool), la advertencia aún no desaparece.

¿Cuál es el trato, yo? ¿Por qué es una advertencia de rendimiento? Pensé que sería menos eficiente escribir algo como:

bool hasParent() {
    if (this->parentNode)
        return true;
    else
        return false;
}

Pero la segunda versión no genera advertencias y el compilador parece mucho más feliz. Sin embargo, ¿cuál es más rápido?

Question 2

Hay una discusión en Microsoft Connect sobre esto (¿Cuál es la implicación de rendimiento de convertir a bool en C++?). El ejemplo dado a Microsoft es:

$ cat -n t.cpp && cl -c -W3 -O2 -nologo -Fa t.cpp
1 bool f1 (int i)
2 {
3 return i & 2;
4 }
5
6 bool f2 (int i)
7 {
8 const bool b = i & 2;
9 return b;
10 }
11
12 bool f3 (int i)
13 {
14 const bool b = 0 != (i & 2);
15 return b;
16 }
t.cpp
t.cpp(3) : warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
t.cpp(8) : warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)

Y la respuesta de Microsoft (del desarrollador responsable de la advertencia) es:

Esta advertencia es sorprendentemente útil y ayer encontré un error en mi código. Creo que Martin está sacando de contexto la “advertencia de desempeño”.

No se trata del código generado, se trata de si el programador ha señalado o no la intención de cambiar un valor de int a bool. Hay una penalización por eso, y el usuario tiene la opción de usar “int” en lugar de “bool” de manera consistente (o más probablemente viceversa) para evitar la generación de código “boolificante”. La advertencia se suprime en el tercer caso a continuación porque indica claramente su intención de aceptar la transición int->bool.

Es una advertencia antigua y puede haber sobrevivido a su propósito, pero se está comportando como se diseñó aquí.

Así que, básicamente, el desarrollador de MS parece estar diciendo que si desea “lanzar” un int a bool deberías hacerlo más correctamente usando “return this->parentNode != 0” en lugar de un molde implícito o explícito.

Personalmente, me interesaría saber más sobre qué tipo de errores descubre la advertencia. Creo que esta advertencia no tendría mucho valor.

Question 3

El hecho de que lanzar a bool no hace que la advertencia desaparezca es por diseño:

Convertir la expresión al tipo bool no deshabilitará la advertencia, que es por diseño.

Recomendaría el enfoque que recomienda la descripción de MSDN de la advertencia C4800:

return this->parentNode != NULL;

esto deja claro que vas a volver true si parentNode no es un puntero nulo y false si parentNode es un puntero nulo.

Question 4

El compilador necesita generar código adicional para convertir un puntero a bool. Básicamente es una comparación contra cero y establecer el resultado en uno, si no cero.

00000000004005e0 <_Z4testPv>:
bool test(void* adr) {
  4005e0:       48 85 ff                test   %rdi,%rdi
  4005e3:       0f 95 c0                setne  %al
    return adr;
}
  4005f8:       c3                      retq

Esto no es directamente visible desde la fuente, por lo que el compilador cree que esto es algo sobre lo que se debe advertir al usuario.

Question 5

¿Por qué es una advertencia de rendimiento?

El compilador está convirtiendo esto:

bool hasParent()
{
  return this->parentNode;
}

dentro:

bool hasParent()
{
  return this->parentNode != 0;
}

Esto toma alrededor un ciclo de reloj más de lo que cabría esperar al mirar el código. Es una diferencia de rendimiento insignificante.

Creo que es mejor escribir el != 0 explícitamente de todos modos, ya que hace que el código sea más claro y silencia la advertencia.

Question 6

Sería más eficiente escribir:

bool hasParent()
{
    return  this->parentNode != NULL;
}

Question 7

Siendo realistas, creo que se optimizarían de la misma manera, también puedes intentar hacer esto:

return this->parentNode != 0;

¿Ha sido útil esta solución?