Nowadays, with C++11, Whats recommended to use, Zero or NULL? The first of the second if?
int * p = getPointer(); if( 0 == p ){ // something } if( NULL == p ){ // something } UPDATE: I forget the new
if( nullptr == p ){ // something } UPDATE 2: the examples are to show the options to write null pointer, I know is more pleasant to write if( !p ).
The other answers are right. But I wanted to say a little more about why nullptr is better.
In C++11 "perfect forwarding" is very important. It is used everywhere. Obvious places are bind and function. But it is also used in a multitude of other places under the covers. But "perfect forwarding" isn't perfect. And one of the places it fails is null pointer constants.
template <class T> void display(T) { std::cout << type_name<T>() << '\n'; } template <class T> void f(T&& t) { display(std::forward<T>(t)); // "perfectly forward" T } int main() { f(0); f(NULL); f(nullptr); } With an appropriate definition of type_name<T>(), on my system this prints out:
int long std::nullptr_t This can easily make the difference between working code and errors. With any luck your errors will come at compile time (with horrible error messages). But you may also get run time errors in some circumstances.
Aggressively ban use of 0 and NULL in your code.
Even if you're not perfect forwarding in your code, code you call (such as the std::lib) is very likely using it under the covers.
NULL is defined as nullptr, isn't it? Then why explicit nullptr is better than NULL? Or maybe this answer is simply outdated?Neither, it's nullptr.
Though, in your case, I'd just go with
if ( !p ){ //something } 1 The pointer literal is the keyword
nullptr. It is a prvalue of typestd::nullptr_t. [ Note:std::nullptr_tis a distinct type that is neither a pointer type nor a pointer to member type; rather, a prvalue of this type is a null pointer constant and can be converted to a null pointer value or null member pointer value.
p == nullprt and p != nullptr
nullptr actually meant :) This was a new one to me, but a very useful one.
!p. I find if(p) and if(!p) much easier to read than the more wordy alternatives.
bool occurs (it doesn't). Per the C++ standard on bool conversions: "A prvalue of arithmetic, unscoped enumeration, pointer, or pointer to member type can be converted to a prvalue of type bool. A zero value, null pointer value, or null member pointer value is converted to false; any other value is converted to true." (emphasis added) C++ follows C's behavior; most tests care about 0/non-zero, NULL/non-NULL, not true or false.C++11 has a new literal keyword nullptr. It's better than 0 or NULL for things like this because there's no chance it will be used as an int in overload resolution.
if ( nullptr == p ) Or of course you can just use a pointer in a bool context:
if ( !p ) If you have the same problem in 2019, You are using an older initialization style for unassigned pointers. After 2014 August 14 the C++ 11 released. The compiler you are using is probably following the C++11 standard.
You can just replace
0/NULLwithnullptr
Modern C++ offers nullptr as a universal null pointer. You should use that instead of 0 || NULL because there are some obscure machines that have things like signed pointers where a null pointer is actually something like -1 rather than 0.
(void*)0. Of course the better option in C++11 isnullptr, but in C++03 I prefer0toNULL.