Is C NULL equal to C++11 nullptr

Question

I like to use nullptr instead of NULL. Now I call a C function (from libjansson in this case).

NULL in C is implementation defined.

For nullptr I found that "A null pointer constant is an integral constant expression (5.19) rvalue of integer type that evaluates to zero".

So the safest thing to do:

auto string_obj=json_object_get(m_handle,name);
if(string_obj!=NULL)
    {
    auto string=json_string_value(string_obj);
    if(string!=NULL)
        {return string;}
    }
return nullptr;

Do I really need that or can I do it simpler:

auto string_obj=json_object_get(m_handle,name);
if(string_obj!=nullptr)
    {
    return json_string_value(string_obj); //Assume there is no difference between C NULL and C++11 nullptr
    }
return nullptr;

Answer 1

In C++11 and beyond, a pointer that is ==NULL will also ==nullptr and vice versa.

Uses of NULL other than comparing with a pointer (like using it to represent the nul byte at the end of a string) won't work with nullptr.

In some cases, NULL is #define NULL 0, as the integer constant 0 is special-cased in C and C++ when you compare it with pointers. This non-type type information causes some problems in both C and C++, so in C++ they decided to create a special type and value that does the same thing in the "proper" use cases, and reliably fails to compile in most of the "improper" use cases.

Insofar as your C++ implementation is compatible with the C implementation you are interoping with (very rare for this not to be true), everything should work.

---

To be very clear, if ptr is any kind of pointer, then the following expressions are equivalent in C++:

ptr == nullptr ptr == NULL ptr == 0 !ptr 

As are the following:

ptr = nullptr ptr = NULL ptr = 0 

and if X is some type, so are the following statements:

X* ptr = nullptr; X* ptr = NULL; X* ptr = 0; 

nullptr differs when you pass it to a template function that deduces type (NULL or 0 become an int unless passed to an argument expecting a pointer, while nullptr remains a nullptr_t), and when used in some contexts where nullptr won't compile (like char c = NULL;) (note, not char* c=NULL;)

Finally, literally:

NULL == nullptr 

is true.

The NULL constant gets promoted to a pointer type, and as a pointer it is a null pointer, which then compares equal to nullptr.

---

Despite all this, it isn't always true that:

 foo(NULL) 

and

 foo(nullptr) 

do the same thing.

void bar(int) { std::cout << "int\n"; } void bar(void*) { std::cout << "void*\n"; } template<class T> void foo(T t) { bar(t); } foo(NULL); foo(nullptr); 

this prints int for NULL and void* for nullptr.