How is 0 distinguished from other integers when initializing nullptr_t?

Question

As I understand, std::nullptr_t can be initialized from nullptr as well as from 0. But at the same time the third initialization below doesn't work, despite 5 has the same type as 0:

#include <memory>

int main()
{
    std::nullptr_t null1=0;
    std::nullptr_t null2=nullptr;
    std::nullptr_t null3=5; // error: cannot convert ‘int’ to ‘std::nullptr_t’ in initialization
}

How does this work? I.e. how does the standard library distinguish 0 from 5 at compilation time, if these literals aren't template arguments?

Can one create a custom class which would similarly distinguish arguments of its constructor at compilation time, not using std::nullptr_t for this?

Answer 1

A nullptr_t can be only assigned the value nullptr or 0 which is implicitly converted.

According to N4296 (page.86):

4.10 Pointer conversions

A null pointer constant is an integer literal with value zero or a prvalue of type std::nullptr_t. A null pointer constant can be converted to a pointer type; the result is the null pointer value of that type and is distinguishable from every other value of object pointer or function pointer type. [...] A null pointer constant of integral type can be converted to a prvalue of type std::nullptr_t.

You can not create a similar type within C++ yourself.

std::nullptr_t is implemented as a built-in type and its distinct properties are enforced by the compiler.

---

EDIT: Fixed paragraph on built-in types. Thanks Yakk!

Answer 2

how does the standard library distinguish 0 from 5 at compilation time, if these literals aren't template arguments?

This has nothing to do with the standard library at all, nullptr_t is a built-in type known to the compiler, and obviously the compiler knows the difference between 5 and 0

Can one create a custom class which would similarly distinguish arguments of its constructor at compilation time, not using std::nullptr_t for this?

In general no.

You can write a type that can be initialized from 0 and not from 5 by making it take an argument of a pointer type, because 0 is a valid null pointer constant but 5 is not. But you couldn't write a type that can be constructed from 3 and not from 5, or anything else like that.

Answer 3

N3337 [conv.ptr]/1: A null pointer constant is an integral constant expression prvalue of integer type that evaluates to zero or a prvalue of type std::nullptr_t. A null pointer constant can be converted to a pointer type; the result is the null pointer value of that type and is distinguishable from every other value of object pointer or function pointer type. Such a conversion is called a null pointer conversion. Two null pointer values of the same type shall compare equal. The conversion of a null pointer constant to a pointer to cv-qualified type is a single conversion, and not the sequence of a pointer conversion followed by a qualification conversion. A null pointer constant of integral type can be converted to a prvalue of type std::nullptr_t.

0 is a null pointer constant of integral type, so it can be converted to a prvalue of type std::nullptr_t. 5 is not a null pointer constant, so it can't be.