nullptr的基础
std::nullptr_t是空指针文字nullptr的类型。它是类型的prvalue / rvalue std::nullptr_t。存在从nullptr到任何指针类型的null指针值的隐式转换。
文字0是一个int，而不是一个指针。如果C ++在只能使用指针的上下文中发现自己正在查看0，它将勉强将0解释为空指针，但这是一个后备位置。C ++的主要策略是0是一个整数，而不是一个指针。
优点1-消除指针和整数类型重载时的歧义
在C ++ 98中，其主要含义是指针和整数类型的重载可能会导致意外情况。将0或NULL传递给此类重载从不称为指针重载：
void fun(int); // two overloads of fun
void fun(void*);
fun(0); // calls f(int), not fun(void*)
fun(NULL); // might not compile, but typically calls fun(int). Never calls fun(void*)
关于该调用的有趣之处在于源代码的表观含义（“我正在用NULL-空指针调用乐趣”）与其实际含义（“我正在用某种整数而不是null调用乐趣”）之间的矛盾。指针”）。
nullptr的优点是它没有整数类型。用nullptr调用重载函数fun会调用void *重载（即指针重载），因为nullptr不能被视为任何整数：
fun(nullptr); // calls fun(void*) overload
因此，使用nullptr而不是0或NULL可以避免重载解析意外。
使用auto作为返回类型时的nullptrover的另一个优点NULL(0)
例如，假设您在代码库中遇到此问题：
auto result = findRecord( /* arguments */ );
if (result == 0) {
....
}
如果您不知道（或不容易发现）findRecord返回什么，则可能不清楚结果是指针类型还是整数类型。毕竟，0（测试结果的依据）都可以。另一方面，如果您看到以下内容，
auto result = findRecord( /* arguments */ );
if (result == nullptr) {
...
}
没有歧义：结果必须是指针类型。
优势3
#include<iostream>
#include <memory>
#include <thread>
#include <mutex>
using namespace std;
int f1(std::shared_ptr<int> spw) // call these only when
{
//do something
return 0;
}
double f2(std::unique_ptr<int> upw) // the appropriate
{
//do something
return 0.0;
}
bool f3(int* pw) // mutex is locked
{
return 0;
}
std::mutex f1m, f2m, f3m; // mutexes for f1, f2, and f3
using MuxtexGuard = std::lock_guard<std::mutex>;
void lockAndCallF1()
{
MuxtexGuard g(f1m); // lock mutex for f1
auto result = f1(static_cast<int>(0)); // pass 0 as null ptr to f1
cout<< result<<endl;
}
void lockAndCallF2()
{
MuxtexGuard g(f2m); // lock mutex for f2
auto result = f2(static_cast<int>(NULL)); // pass NULL as null ptr to f2
cout<< result<<endl;
}
void lockAndCallF3()
{
MuxtexGuard g(f3m); // lock mutex for f2
auto result = f3(nullptr);// pass nullptr as null ptr to f3
cout<< result<<endl;
} // unlock mutex
int main()
{
lockAndCallF1();
lockAndCallF2();
lockAndCallF3();
return 0;
}
上面的程序成功编译并执行，但是lockAndCallF1，lockAndCallF2和lockAndCallF3具有冗余代码。如果我们可以为所有这些模板编写模板，那么遗憾的是编写这样的代码lockAndCallF1, lockAndCallF2 & lockAndCallF3。因此可以用模板来概括。我编写了模板函数，lockAndCall而不是lockAndCallF1, lockAndCallF2 & lockAndCallF3为冗余代码定义了多个模板。
代码重构如下：
#include<iostream>
#include <memory>
#include <thread>
#include <mutex>
using namespace std;
int f1(std::shared_ptr<int> spw) // call these only when
{
//do something
return 0;
}
double f2(std::unique_ptr<int> upw) // the appropriate
{
//do something
return 0.0;
}
bool f3(int* pw) // mutex is locked
{
return 0;
}
std::mutex f1m, f2m, f3m; // mutexes for f1, f2, and f3
using MuxtexGuard = std::lock_guard<std::mutex>;
template<typename FuncType, typename MuxType, typename PtrType>
auto lockAndCall(FuncType func, MuxType& mutex, PtrType ptr) -> decltype(func(ptr))
//decltype(auto) lockAndCall(FuncType func, MuxType& mutex, PtrType ptr)
{
MuxtexGuard g(mutex);
return func(ptr);
}
int main()
{
auto result1 = lockAndCall(f1, f1m, 0); //compilation failed
//do something
auto result2 = lockAndCall(f2, f2m, NULL); //compilation failed
//do something
auto result3 = lockAndCall(f3, f3m, nullptr);
//do something
return 0;
}
详细分析为何编译失败而lockAndCall(f1, f1m, 0) & lockAndCall(f3, f3m, nullptr)不是失败lockAndCall(f3, f3m, nullptr)
为什么编译lockAndCall(f1, f1m, 0) & lockAndCall(f3, f3m, nullptr)失败？
问题在于，当将0传递给lockAndCall时，模板类型推导会开始计算其类型。0的类型是int，所以这是在对lockAndCall的调用实例化内的参数ptr的类型。不幸的是，这意味着在lockAndCall内对func的调用中，正在传递一个int，这与期望的std::shared_ptr<int>参数不兼容f1。调用中传递的0 lockAndCall旨在表示空指针，但实际传递的是int。尝试将此int作为a传递给f1 std::shared_ptr<int>是类型错误。对lockAndCall0 的调用失败，因为在模板内部将int传递给需要的函数std::shared_ptr<int>。
涉及呼叫的分析NULL基本相同。当NULL传递给时lockAndCall，将为参数ptr推导一个整数类型，并且在将ptrint或类似int的类型传递给时f2，会产生类型错误，该类型期望得到a std::unique_ptr<int>。
相反，涉及的呼叫nullptr没有问题。当nullptr被传递到lockAndCall，该类型ptr推断为std::nullptr_t。当ptr传递给时f3，存在从std::nullptr_t到的隐式转换int*，因为std::nullptr_t隐式转换为所有指针类型。
建议您在每次要引用空指针时，都使用nullptr而不是0或NULL。
int和void *不会选择int版本在void *使用时的版本nullptr。