Nullptr不能赋值给整型类型，比如int型，只能赋值给指针类型;内置指针类型，如int *ptr或智能指针，如std::shared_ptr<T>

我相信这是一个重要的区别，因为NULL仍然可以被赋给整型和指针，因为NULL是一个扩展到0的宏，可以作为int的初始值以及指针。

它如何既是关键字又是类型的实例?

这并不奇怪。true和false都是关键字，作为字面量，它们有一个类型(bool)。Nullptr是一个std::nullptr_t类型的指针字面值，它是一个prvalue(不能使用&获取它的地址)。

4.10 about pointer conversion says that a prvalue of type std::nullptr_t is a null pointer constant, and that an integral null pointer constant can be converted to std::nullptr_t. The opposite direction is not allowed. This allows overloading a function for both pointers and integers, and passing nullptr to select the pointer version. Passing NULL or 0 would confusingly select the int version. A cast of nullptr_t to an integral type needs a reinterpret_cast, and has the same semantics as a cast of (void*)0 to an integral type (mapping implementation defined). A reinterpret_cast cannot convert nullptr_t to any pointer type. Rely on the implicit conversion if possible or use static_cast. The Standard requires that sizeof(nullptr_t) be sizeof(void*).

它是关键字，因为标准将这样指定它。;-)根据最新公开草案(n2914)

2.14.7指针字面量[lex.nullptr] pointer-literal: nullptr 指针字面值是关键字nullptr。它是std::nullptr_t类型的右值。

它很有用，因为它没有隐式地转换成一个整数值。

为什么在c++ 11中使用nullptr ?是什么?为什么NULL是不充分的?

c++专家Alex Allain在这里说得很好(我用粗体加了重点):

...imagine you have the following two function declarations: void func(int n); void func(char *s); func( NULL ); // guess which function gets called? Although it looks like the second function will be called--you are, after all, passing in what seems to be a pointer--it's really the first function that will be called! The trouble is that because NULL is 0, and 0 is an integer, the first version of func will be called instead. This is the kind of thing that, yes, doesn't happen all the time, but when it does happen, is extremely frustrating and confusing. If you didn't know the details of what is going on, it might well look like a compiler bug. A language feature that looks like a compiler bug is, well, not something you want. Enter nullptr. In C++11, nullptr is a new keyword that can (and should!) be used to represent NULL pointers; in other words, wherever you were writing NULL before, you should use nullptr instead. It's no more clear to you, the programmer, (everyone knows what NULL means), but it's more explicit to the compiler, which will no longer see 0s everywhere being used to have special meaning when used as a pointer.

Allain在文章结尾写道:

不管这些——c++ 11的经验法则是，只要在过去使用NULL，就开始使用nullptr。

(我的话):

最后，不要忘记nullptr是一个对象——一个类。它可以在任何之前使用NULL的地方使用，但如果你因为某种原因需要它的类型，它的类型可以用decltype(nullptr)提取，或者直接描述为std::nullptr_t，这只是一个decltype(nullptr)的类型定义，如下所示:

定义在头<cstddef>:

See:

https://en.cppreference.com/w/cpp/types/nullptr_t 和https://en.cppreference.com/w/cpp/header/cstddef

namespace std
{
typedef decltype(nullptr) nullptr_t; // (since C++11)
// OR (same thing, but using the C++ keyword `using` instead of the C and C++ 
// keyword `typedef`):
using nullptr_t = decltype(nullptr); // (since C++11)
} // namespace std

引用:

c++ 11中更好的类型- nullptr，枚举类(强类型枚举)和cstdint https://en.cppreference.com/w/cpp/language/decltype https://en.cppreference.com/w/cpp/types/nullptr_t https://en.cppreference.com/w/cpp/header/cstddef https://en.cppreference.com/w/cpp/keyword/using https://en.cppreference.com/w/cpp/keyword/typedef

让我首先给您一个简单的nullptr_t的实现

struct nullptr_t 
{
    void operator&() const = delete;  // Can't take address of nullptr

    template<class T>
    inline operator T*() const { return 0; }

    template<class C, class T>
    inline operator T C::*() const { return 0; }
};

nullptr_t nullptr;

nullptr是返回类型解析器习惯用法的一个微妙示例，它根据分配给实例的类型自动推导出正确类型的空指针。

int *ptr = nullptr;                // OK
void (C::*method_ptr)() = nullptr; // OK

如上所述，当nullptr被赋值给整数指针时，将创建模板化转换函数的int类型实例化。方法指针也是一样。 通过这种方式利用模板功能，我们实际上每次都创建了适当类型的空指针，这是一个新的类型赋值。 因为nullptr是一个值为0的整型字面值，你不能使用它的地址，这是我们通过删除&操作符实现的。

为什么我们首先需要nullptr ?

你可以看到传统的NULL有一些问题，如下:

1️⃣隐式转换

char *str = NULL; // Implicit conversion from void * to char *
int i = NULL;     // OK, but `i` is not pointer type

2️⃣函数调用歧义

void func(int) {}
void func(int*){}
void func(bool){}

func(NULL);     // Which one to call?

编译会产生以下错误:

error: call to 'func' is ambiguous
    func(NULL);
    ^~~~
note: candidate function void func(bool){}
                              ^
note: candidate function void func(int*){}
                              ^
note: candidate function void func(int){}
                              ^
1 error generated.
compiler exit status 1

3️⃣构造函数重载

struct String
{
    String(uint32_t)    {   /* size of string */    }
    String(const char*) {       /* string */        }
};

String s1( NULL );
String s2( 5 );

在这种情况下，需要显式强制转换(即String s((char*)0))。

Nullptr不能赋值给整型类型，比如int型，只能赋值给指针类型;内置指针类型，如int *ptr或智能指针，如std::shared_ptr<T>

我相信这是一个重要的区别，因为NULL仍然可以被赋给整型和指针，因为NULL是一个扩展到0的宏，可以作为int的初始值以及指针。