En C ++ 11 y posteriores, un puntero que es ==NULL también va a ==nullptr y viceversa.
Usos de NULL aparte de comparar con un puntero (como usarlo para representar el byte nulo al final de una cadena) no funcionará con nullptr.
En algunos casos, NULL es #define NULL 0, como la constante entera 0 tiene un formato especial en C y C ++ cuando se compara con punteros. Esta información de tipo que no es de tipo causa algunos problemas tanto en C como en C ++, por lo que en C ++ decidieron crear un tipo y valor especiales que hacen lo mismo en los casos de uso «adecuados» y no compilan de manera confiable en la mayoría de los » casos de uso «inapropiados».
Siempre que su implementación de C ++ sea compatible con la implementación de C con la que interopera (muy raro que esto no sea cierto), todo debería funcionar.
Para ser muy claro, si ptr es cualquier tipo de puntero, entonces las siguientes expresiones son equivalentes en C ++:
ptr == nullptr
ptr == NULL
ptr == 0
!ptr
Como son los siguientes:
ptr = nullptr
ptr = NULL
ptr = 0
y si X es de algún tipo, también lo son las siguientes declaraciones:
X* ptr = nullptr;
X* ptr = NULL;
X* ptr = 0;
nullptr difiere cuando lo pasa a una función de plantilla que deduce el tipo (NULL o 0 conviértete en un int a menos que se pase a un argumento esperando un puntero, mientras nullptr sigue siendo una nullptr_t), y cuando se utiliza en algunos contextos donde nullptr no compilará (como char c = NULL;) (nota, no char* c=NULL;)
Finalmente, literalmente:
NULL == nullptr
es verdad.
los NULL constante se promueve a un tipo de puntero, y como puntero es un puntero nulo, que luego se compara igual a nullptr.
A pesar de todo esto, no siempre es cierto que:
foo(NULL)
y
foo(nullptr)
hacer la misma cosa.
void bar(int) { std::cout << "intn"; }
void bar(void*) { std::cout << "void*n"; }
template<class T>
void foo(T t) { bar
foo(NULL);
foo(nullptr);
esto imprime int por NULL y void* por nullptr.