2

Lets say I have a pointer

MyType *ptr;

When checking the validity of that pointer in a "truth-value context" by the old standards I would write something like this

if (ptr)    { ... // 1
while (ptr) { ... // 2

The thing is that in such "truth value contexes" we expect for the implicit conversion of a pointer to a boolean value to take place, so we would be pretty much be comparing 

if (NULL != ptr)    { ...
while (NULL != ptr) { ...

Yet comparing against a macro for the integer 0 is deprecated and C++11 proposes comparing against nullptr.

When in a truth value context though like (1) or (2) above where we don't explicitly say 

if (nullptr != ptr) { ...
while (nullptr != ptr) { ...

what is our pointer compared against ? It's conversion to a boolean ? Do we have to explicitly compare against nullptr ?

Community
  • 1
  • 1
Nikos Athanasiou
  • 29,616
  • 15
  • 87
  • 153
  • Have you read [conv.bool]? http://stackoverflow.com/q/17772103/420683 – dyp May 13 '14 at 17:53
  • @dyp No, I'm reading Bjarne's book and I see that everywhere he says `if (nullptr != ptr)` and that got me to think – Nikos Athanasiou May 13 '14 at 17:54
  • 2
    All of above is valid and I guess none of the future standards will break it (Besides, never say never) –  May 13 '14 at 17:55
  • I'm not sure whether to close it as a dup or provide a better answer here.... besides the boolean conversion, there's [stmt.select]/4 which states that the condition of an if-statement is contextually converted to `bool` which then triggers the boolean conversion. – dyp May 13 '14 at 17:58
  • The other thread is way too cluttered to provide an answer that will clarify things. I'd propose the second – Nikos Athanasiou May 13 '14 at 18:00

2 Answers2

5

The condition (if it's an expression) of an if statement is contextually converted to bool:

[stmt.select]/4 about the condition in selection statements (if, switch):

The value of a condition that is an expression is the value of the expression, contextually converted to bool for statements other than switch; if that conversion is ill-formed, the program is ill-formed.

Contextual conversion to bool is defined as follows in [conv]/3:

An expression e can be implicitly converted to a type T if and only if the declaration T t=e; is well-formed, for some invented temporary variable t. Certain language constructs require that an expression be converted to a Boolean value. An expression e appearing in such a context is said to be contextually converted to bool and is well-formed if and only if the declaration bool t(e); is well-formed, for some invented temporary variable t.

Here's the description of a conversion to bool for fundamental types [conv.bool]/1:

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. A prvalue of type std::nullptr_t can be converted to a prvalue of type bool; the resulting value is false.

So when we test a pointer if(ptr), we compare ptr to the null pointer value of that type. What's a null pointer value? [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.

This also describes what happens when we compare if(ptr != nullptr): The nullptr is converted to the type of ptr (see [expr.rel]/2), and yields the null pointer value of that type. Hence, the comparison is equivalent to if(ptr).

dyp
  • 38,334
  • 13
  • 112
  • 177
1

Let's say you have:

int* ip = foo();
if ( nullptr == ip )
{
}

It's as if you are saying:

int* ip = foo();
if ( (int*)0 == ip )
{
}

At that point, you are comparing two pointers of the same type.

This is what I found at cppreference.com

Explanation

The keyword nullptr denotes the null pointer literal. It is an unspecified prvalue of type std::nullptr_t. There exist implicit conversions from nullptr to null pointer value of any pointer type and any pointer to member type. Similar conversions exist for any value of type std::nullptr_t as well as for the macro NULL, the null pointer constant.

Community
  • 1
  • 1
R Sahu
  • 204,454
  • 14
  • 159
  • 270