¿Puedo usar if (puntero) en lugar de if (puntero! = NULL)?

¿Es seguro marcar un puntero para no estar NULLescribiendo simplemente if(pointer)o tengo que usarlo if(pointer != NULL)?

Usted puede; el puntero nulo se convierte implícitamente en falso booleano, mientras que los punteros no nulos se convierten en verdadero. Desde el estándar C ++ 11, sección sobre conversiones booleanas:

Un valor de aritmética, enumeración sin ámbito, puntero o puntero a tipo de miembro se puede convertir a un valor de tipo bool. Se convierte un valor cero, un valor de puntero nulo o un valor de puntero de miembro nulo false; cualquier otro valor se convierte a true . Un valor de tipo std::nullptr_t puede convertirse en un valor de tipo bool ; el valor resultante es false .

Si, podrías.

• Un puntero nulo se convierte en falso implícitamente
• un puntero no nulo se convierte en verdadero.

Esto es parte de la conversión estándar de C ++, que se incluye en la cláusula de conversión booleana :

§ 4.12 Conversiones booleanas

Un valor de aritmética, enumeración sin ámbito, puntero o puntero a tipo de miembro se puede convertir en un valor de tipo bool. Un valor cero, un valor de puntero nulo o un valor de puntero de miembro nulo se convierte en falso; cualquier otro valor se convierte en verdadero. Un valor prva de tipo std :: nullptr_t puede convertirse en un valor prva de tipo bool; El valor resultante es falso.

Sí tu puedes. De hecho, prefiero usarlo if(pointer)porque es más fácil de leer y escribir una vez que te acostumbras.

También tenga en cuenta que C ++ 11 introdujo nullptrque se prefiere sobre NULL.

La pregunta está respondida, pero me gustaría agregar mis puntos.

Siempre preferiré en if(pointer)lugar de if(pointer != NULL)y en if(!pointer)lugar de if(pointer == NULL):

• Es simple, pequeño

• Menos posibilidades de escribir un código erróneo, supongo que si lo escribo mal operador de comprobación de igualdad ==con =
if(pointer == NULL)pueden estar mal escritas if(pointer = NULL)Así que voy a evitarlo, lo mejor es simplemente if(pointer).
  _{(También sugerí alguna condición de Yoda en una respuesta , pero esa es una cuestión diferente)}

• Del mismo modo while (node != NULL && node->data == key), simplemente escribiré lo while (node && node->data == key)que es más obvio para mí (lo demuestra usando cortocircuito).

• (puede ser una razón estúpida) Porque NULL es una macro, si se supone que alguien redefine por error con otro valor.

La comprobación explícita de NULL podría proporcionar una pista al compilador sobre lo que está tratando de hacer, por lo que puede ser menos propenso a errores.

Sí tu puedes. La capacidad de comparar valores con ceros implícitamente se ha heredado de C, y existe en todas las versiones de C ++. También puede usar if (!pointer)para verificar los punteros para NULL.

Los casos de uso relevantes para punteros nulos son

• Redirección a algo como un nodo de árbol más profundo, que puede no existir o no ha sido vinculado todavía. Eso es algo que siempre debes mantener encapsulado en una clase dedicada, por lo que la legibilidad o la concisión no son un gran problema aquí.

• Moldes dinámicos. Lanzar un puntero de clase base a uno particular de clase derivada (algo que debería intentar evitar de nuevo, pero que a veces puede ser necesario) siempre tiene éxito, pero da como resultado un puntero nulo si la clase derivada no coincide. Una forma de verificar esto es

  Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
  if(derived_ptr != nullptr) { ... }

  (o, preferiblemente auto derived_ptr = ...) Ahora, esto es malo, porque deja el puntero derivado (posiblemente inválido, es decir, nulo) fuera del ifalcance del bloque de protección de seguridad . Esto no es necesario, ya que C ++ le permite introducir variables booleanas convertibles dentro de una ifcondición :

  if(auto derived_ptr = dynamic_cast<Derived*>(base_ptr)) { ... }

  que no solo es más corto y seguro para el alcance, también es mucho más claro en su intención: cuando verifica nulo en una condición if separada, el lector se pregunta "ok, entonces derived_ptrno debe ser nulo aquí ... bueno, ¿por qué será nulo? Mientras que la versión de una sola línea dice muy claramente "si se puede transmitir de forma segura base_ptraDerived* , y luego usarlo para ...".

  Lo mismo funciona igual de bien para cualquier otra operación de posible falla que devuelva un puntero, aunque IMO generalmente debería evitar esto: es mejor usar algo boost::optionalcomo el "contenedor" para obtener resultados de posibles operaciones fallidas, en lugar de punteros.

Entonces, si el caso de uso principal para punteros nulos siempre se debe escribir en una variación del estilo implícito, diría que es bueno, por razones de coherencia, usar siempre este estilo, es decir, abogaría por if(ptr)más if(ptr!=nullptr).

Me temo que tengo que terminar con un anuncio: la if(auto bla = ...)sintaxis es en realidad una aproximación un poco engorrosa a la solución real a tales problemas: la coincidencia de patrones . ¿Por qué forzarías primero alguna acción (como lanzar un puntero) y luego considerarías que podría haber una falla ... Quiero decir, es ridículo, ¿no? Es como si tuvieras algo de comida y quieres hacer sopa. Se lo entrega a su asistente con la tarea de extraer el jugo, si resulta ser un vegetal blando. No lo miras primero. Cuando tienes una papa, todavía se la das a tu asistente, pero te la devuelven en la cara con una nota de falla. ¡Ah, programación imprescindible!

Mucho mejor: considere de inmediato todos los casos que pueda encontrar. Entonces actúa en consecuencia. Haskell

makeSoupOf :: Foodstuff -> Liquid
makeSoupOf p@(Potato{..}) = mash (boil p) <> water
makeSoupOf vegetable
 | isSoft vegetable  = squeeze vegetable <> salt
makeSoupOf stuff  = boil (throwIn (water<>salt) stuff)

Haskell también tiene herramientas especiales para cuando realmente existe una posibilidad seria de falla (así como para un montón de otras cosas): mónadas. Pero este no es el lugar para explicarlos.

^{⟨/Propaganda⟩}

¡sí, por supuesto! de hecho, escribir if (puntero) es una forma más conveniente de escribir que if (puntero! = NULL) porque: 1. es fácil de depurar 2. fácil de entender 3. si accidentalmente, se define el valor de NULL, entonces también el código no se bloqueará

Si. De hecho deberías. Si se pregunta si crea una falla de segmentación , no lo hace.

Como otros ya respondieron bien, ambos son intercambiables.

Sin embargo, vale la pena mencionar que podría haber un caso en el que desee utilizar la declaración explícita, es decir pointer != NULL.

Ver también https://stackoverflow.com/a/60891279/2463963

Sí, siempre puede hacer esto ya que la condición 'SI' se evalúa solo cuando la condición dentro de ella se cumple. C no tiene un tipo de retorno booleano y, por lo tanto, devuelve un valor distinto de cero cuando la condición es verdadera, mientras que devuelve 0 siempre que la condición en 'IF' sea falsa. El valor distinto de cero devuelto por defecto es 1. Por lo tanto, ambas formas de escribir el código son correctas, mientras que siempre preferiré el segundo.

Creo que, como regla general, si su expresión if puede reescribirse como

const bool local_predicate = *if-expression*;
if (local_predicate) ...

de modo que NO provoque ADVERTENCIAS, entonces ESE debería ser el estilo preferido para la expresión if . (Sé que recibo advertencias cuando asigno un C BOOL( #define BOOL int) antiguo a un C ++ bool, por no hablar de punteros).

"Es seguro..?" es una pregunta sobre el estándar de idioma y el código generado.

"¿Es una buena práctica?" es una pregunta sobre qué tan bien la declaración es entendida por cualquier lector humano arbitrario de la declaración. Si hace esta pregunta, sugiere que la versión "segura" es menos clara para futuros lectores y escritores.