It’s because you declare b to be a pointer, and initialize it to be a null pointer. But a null pointer to what type of data you don’t say, so the compiler can’t deduce the type. If you want b to be a std::nullptr_t object, you should drop the asterisk: auto b{nullptr};
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
If more than one overload accepts a pointer type, an overload for std::nullptr_t is necessary to accept a nullptr argument. Without the std::nullptr_t overload, it would be ambiguous which pointer overload should be selected when passed nullptr. Example: void f(int *intp) { // Passed an int pointer } void f(char *charp) { // Passed a … Read more
nullptr is a C++11 keyword (no different to if, public, true, void, etc.), so namespaces don’t apply.
In C, a void* can be implicitly converted to any T*. As such, making NULL a void* is entirely appropriate. But that’s profoundly dangerous. So C++ did away with such conversions, requiring you to do most pointer casts manually. But that would create source-incompatibility with C; a valid C program that used NULL the way … Read more
Because the syntax says 0, not expression or some other non-terminal matching nullptr. For all the time only 0 has worked. Even 0L would be ill-formed because it does not match the syntax. Edit Clang allows = 0x0, = 0b0 and = 00 (31.12.2013). That is incorrect and should be fixed in the compiler, of … Read more
It will work. From Paragraphs 20.7.1.2.3/8-9 of the C++11 Standard about the unique_ptr<> class template: unique_ptr& operator=(nullptr_t) noexcept; Effects: reset(). Postcondition: get() == nullptr This means that the definition of class template unique_ptr<> includes an overload of operator = that accepts a value of type nullptr_t (such as nullptr) as its right hand side; the … Read more
I have seen below macro in topmost header file: You shouldn’t have seen that, the standard library defines it in <cstddef> (and <stddef.h>). And, IIRC, according to the standard, redefining names defined by standard header files results in undefined behaviour. So from a purely standardese viewpoint, you shouldn’t do that. I’ve seen people do the … Read more
While nullptr is a null pointer constant, it is not a null pointer value. The latter is a value of some pointer type, which std::nullptr_t is not. Reference: A null pointer constant is an integer literal (5.13.2) with value zero or a prvalue of type std::nullptr_t. A null pointer constant can be converted to a … Read more
It’s the same as not being able to take the address of 5 even though you can take the address of an int after giving it the value 5. It doesn’t matter that there’s no alternative value for a nullptr_t to have. Values don’t have addresses; objects do. A temporary object is generated when you … Read more