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
TL;DR: Your example is well-defined. Merely dereferencing a null pointer is not invoking UB. There is a lot of debate over this topic, which basically boils down to whether indirection through a null pointer is itself UB. The only questionable thing that happens in your example is the evaluation of the object expression. In particular, … 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