blocks|key|1923622|text|正如其他人已经说过的，它的主要优势在于重载。虽然显式int和指针重载的情况很少见，但考虑一下像std::fill这样的标准库函数(它在C%2B%2B03中不止一次让我头疼)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1923623|MyClass+*arr[4];
std::fill_n(arr,+4,+NULL);|code-block|syntax|javascript|1923624|不能编译：Cannot+convert+int+to+MyClass*。|1923625|entityMap^0|Q|3|1B|9|0|0|5|U|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Just as others have already said, its primary advantage lies in overloads. And while explicit <code>int</code> vs. pointer overloads can be rare, consider standard library functions like <code>std::fill</code> (which has bitten me more than once in C++03):

<pre><code>MyClass *arr[4];
std::fill_n(arr, 4, NULL);
</code></pre>

Doesn't compile: <code>Cannot convert int to MyClass*</code>.

blocks|key|1710165|text|IMO比这些重载问题更重要:在深度嵌套的模板构造中，很难不跟踪类型，并且给出显式签名是一项相当大的努力。因此，对于您使用的任何东西，越精确地关注预期的目的越好，这将减少对显式签名的需求，并允许编译器在出现错误时生成更有洞察力的错误消息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1710166|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

IMO more important than those overload issues: in deeply nested template constructs, it's hard not to lose track of the types, and giving explicit signatures is quite an endeavour. So for everything that you use, the more precisely focused to the intended purpose, the better, it will reduce the need for explicit signatures and allows the compiler to produce more insightful error messages when something goes wrong.

blocks|key|1923728|text|这里真正的动机是完美的转发。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1923729|考虑一下：|1923730|void+f(int*+p);
template<typename+T>+void+forward(T&&+t)+{
++++f(std::forward<T>(t));
}
int+main()+{
++++forward(0);+//+FAIL
}|code-block|syntax|javascript|1923731|简单地说，0是一个特殊的值，但是值不能通过系统传播-只有类型可以。转发函数是必不可少的，0不能处理它们。因此，引入nullptr是绝对必要的，其中类型是特殊的，并且类型确实可以传播。事实上，MSVC团队在实现了rvalue引用之后，不得不提前引入nullptr，然后自己发现了这个陷阱。|offset|length|style|CODE|1923732|在其他一些情况下，nullptr可以使工作变得更容易-但它不是核心情况，因为cast可以解决这些问题。考虑一下|1923733|void+f(int);
void+f(int*);
int+main()+{+f(0);+f(nullptr);+}|1923734|调用两个单独的重载。此外，请考虑|1923735|void+f(int*);
void+f(long*);
int+main()+{+f(0);+}|1923736|这是不明确的。但是，使用nullptr，您可以提供|1923737|void+f(std::nullptr_t)
int+main()+{+f(nullptr);+}|1923738|entityMap^0|0|0|0|1L|7|3F|7|0|9|7|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@$K|16|L|17|M|N]|$K|18|L|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$K|1B|L|1C|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1F|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1H|8|@]|9|@]|A|$G|H]]|$1|10|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|11|$]]

The real motivation here is perfect forwarding.

Consider:

<pre><code>void f(int* p);
template&lt;typename T&gt; void forward(T&amp;&amp; t) {
 f(std::forward&lt;T&gt;(t));
}
int main() {
 forward(0); // FAIL
}
</code></pre>

Simply put, 0 is a special value, but values cannot propagate through the system- only types can. Forwarding functions are essential, and 0 can't deal with them. Thus, it was absolutely necessary to introduce <code>nullptr</code>, where the type is what is special, and the type can indeed propagate. In fact, the MSVC team had to introduce <code>nullptr</code> ahead of schedule after they implemented rvalue references and then discovered this pitfall for themselves.

There are a few other corner cases where <code>nullptr</code> can make life easier- but it's not a core case, as a cast can solve these problems. Consider

<pre><code>void f(int);
void f(int*);
int main() { f(0); f(nullptr); }
</code></pre>

Calls two separate overloads. In addition, consider

<pre><code>void f(int*);
void f(long*);
int main() { f(0); }
</code></pre>

This is ambiguous. But, with nullptr, you can provide

<pre><code>void f(std::nullptr_t)
int main() { f(nullptr); }
</code></pre>

This piece of code conceptually does the same thing for the three pointers (safe pointer initialization):

<pre><code>int* p1 = nullptr;
int* p2 = NULL;
int* p3 = 0;
</code></pre>

And so, what are the advantages of assigning pointers <code>nullptr</code> over assigning them the values <code>NULL</code> or <code>0</code>?

What are the advantages of using nullptr?

编译器

这段代码在概念上为三个指针做了同样的事情(安全指针初始化)：int* p1 = nullptr;int* p2 = NULL;int* p3 = 0;那么，与赋值NULL或0相比，为指针赋值nullptr有什么优势呢

问使用nullptr有什么好处？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用nullptr有什么好处？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用nullptr有什么好处？
EN