features - c++ override

¿Qué es mejor usar en C++ 11, cero o nulo?

Question

Hoy en día, con C ++ 11, ¿Qué se recomienda usar, Zero o NULL ? El primero del segundo si?

int * p = getPointer();

if( 0 == p ){
    // something
}

if( NULL == p ){
    // something
}

ACTUALIZACIÓN: me olvido del nuevo

if( nullptr == p ){
    // something
}

ACTUALIZACIÓN 2: los ejemplos son para mostrar las opciones para escribir un puntero nulo, sé que es más agradable escribir if( !p ) .

Answer 1

C ++ 11 tiene una nueva palabra clave literal nullptr . Es mejor que 0 o NULL para cosas como esta porque no hay posibilidad de que se use como un int en la resolución de sobrecarga.

if ( nullptr == p )

O, por supuesto, puedes usar un puntero en un contexto bool:

if ( !p )

Answer 2

Las otras respuestas son correctas. Pero quería decir un poco más sobre por qué nullptr es mejor.

En C ++ 11 el "reenvío perfecto" es muy importante. Se utiliza en todas partes. Los lugares obvios son bind y function . Pero también se utiliza en una multitud de otros lugares bajo las cubiertas. Pero el "reenvío perfecto" no es perfecto. Y uno de los lugares en los que falla son las constantes de puntero nulas.

template <class T>
void display(T)
{
    std::cout << type_name<T>() << ''/n'';
}

template <class T>
void
f(T&& t)
{
    display(std::forward<T>(t));  // "perfectly forward" T
}

int main()
{
    f(0);
    f(NULL);
    f(nullptr);
}

Con una definición apropiada de type_name<T>() , en mi sistema esto se imprime:

int
long
std::nullptr_t

Esto puede hacer fácilmente la diferencia entre el código de trabajo y los errores. Con un poco de suerte, tus errores llegarán en tiempo de compilación (con mensajes de error horribles). Pero también puede obtener errores de tiempo de ejecución en algunas circunstancias.

Prohibir agresivamente el uso de 0 y NULL en su código.

Incluso si no eres un reenvío perfecto en tu código, es muy probable que el código al que llamas (como el std :: lib) lo esté usando debajo de las cubiertas.

Answer 3

Tampoco, es nullptr .

Aunque, en tu caso, me gustaría ir con

if ( !p ){
   //something
}

2.14.7 literales de puntero [lex.nullptr]

1 El puntero literal es la palabra clave nullptr . Es un prvalue de tipo std::nullptr_t . [Nota: std::nullptr_t es un tipo distinto que no es un tipo de puntero ni un puntero al tipo de miembro; más bien, un valor predeterminado de este tipo es una constante de puntero nulo y se puede convertir en un valor de puntero nulo o un valor de puntero de miembro nulo.