The Official proposal has a workaround – const // this is a const object… class { public: template<class T> // convertible to any type operator T*() const // of null non-member { return 0; } // pointer… template<class C, class T> // or any type of null operator T C::*() const // member pointer… { … Read more
Stephan T. Lavavej (member of the C++ standard committee) explained that once in a talk (55:35): While an implementation is allowed to #define NULL nullptr, it would break quite some uses like int i = NULL; and apparently there are plenty of those. So they could not force the change.
Is there any real difference, or are there advantages/disadvantages to either approach? The two alternatives are absolutely equivalent, in the sense that the second form (foo = nullptr) is defined in terms of the first one. Per Paragraph 20.7.1.2.3/8-10 of the C++11 Standard: unique_ptr& operator=(nullptr_t) noexcept; 8 Effects: reset(). 9 Postcondition: get() == nullptr 10 … Read more
In that code, there doesn’t seem to be an advantage. But consider the following overloaded functions: void f(char const *ptr); void f(int v); f(NULL); //which function will be called? Which function will be called? Of course, the intention here is to call f(char const *), but in reality f(int) will be called! That is a … Read more
nullptr has type std::nullptr_t. It’s implicitly convertible to any pointer type. Thus, it’ll match std::nullptr_t or pointer types in overload resolution, but not other types such as int. 0 (aka. C’s NULL bridged over into C++) could cause ambiguity in overloaded function resolution, among other things: f(int); f(foo *); (Thanks to Caleth pointing this out … Read more
How is it a keyword and an instance of a type? This isn’t surprising. Both true and false are keywords and as literals they have a type ( bool ). nullptr is a pointer literal of type std::nullptr_t, and it’s a prvalue (you cannot take the address of it using &). 4.10 about pointer conversion … Read more