Equal to operand

[rasayani]

Does anyone know what the advantage is of using the following statement

char *p = NULL;
if (NULL == p)
{

}

over

char *p = NULL;
if (p == NULL)
{

}

 

[Russell Hanneken]

Does anyone know what the advantage is of using the following statement

char *p = NULL;
if (NULL == p)
{

}

over

char *p = NULL;
if (p == NULL)
{

}

This is addressed in the FAQ:

http://www.eskimo.com/~scs/C-faq/q17.4.html

 

[Joona I Palaste]

Does anyone know what the advantage is of using the following statement

char *p = NULL;
if (NULL == p)
{


char *p = NULL;
if (p == NULL)
{

}

The advantage is that if you mistakenly type = instead of ==, the first
form will cause a constraint violation or a syntax error, while the
second form will silently compile and cause p to always be NULL.

 

[Richard Bos]

Does anyone know what the advantage is of using the following statement

char *p = NULL;
if (NULL == p)
{

}

over

char *p = NULL;
if (p == NULL)
{

}

Yes. It will confuse newbies. It is also said to have a beneficiary
effect on typos, but I suspect the placebo effect.

Richard

 

[Christian Bau]

Does anyone know what the advantage is of using the following statement

char *p = NULL;
if (NULL == p)
{

}

over

char *p = NULL;
if (p == NULL)
{

}

Some people use the first form because in that case typing "=" instead
of "==" by accident will produce a syntax error that the compiler will
catch.

On the other hand, turn all warnings on on your compiler (I certainly
hope you do that), and it is most likely that you will get a warning for

if (p = NULL)

as well. And the first version is less readable, which will cost you
long term in maintenance cost.

 

[Gautam]

Yes. It will confuse newbies. It is also said to have a beneficiary
effect on typos, but I suspect the placebo effect.

Richard

exactly

 

[Christopher Benson-Manica]

The advantage is that if you mistakenly type = instead of ==, the first
form will cause a constraint violation or a syntax error, while the
second form will silently compile and cause p to always be NULL.

Although some helpful compilers may warn you about a possibly
incorrect assignment. Such warnings are a double-edged sword, because
you get reprimanded whether you actually made a mistake or not.

 

[John Bode]

Does anyone know what the advantage is of using the following statement

char *p = NULL;
if (NULL == p)
{

}

over

char *p = NULL;
if (p == NULL)
{

}

If you mistakenly type

if (p = NULL) {...}

then p will be assigned NULL instead of compared against null, and the
branch will never be taken, which is a bug. On the other hand, if you
mistakenly type

if (NULL = p) {...}

you will raise a diagnostic at compile time, since NULL cannot be assigned
to. So the NULL == p form is a good way to catch a certain class of typo,
but only in cases where one of the operands is not an lvalue.

For this *specific* instance, you can avoid the headache completely by
typing

if (!p) {...}

since !p is equivalent to p == NULL.

It would have been nice if dmr had realized early on that allowing
assignment expressions in conditionals could lead to problems, or if he had
used a different operator for assignment or equality (i.e., := and ==, or =
and :=, or something where the two operators don't start with the same
character). But he didn't, and we're stuck with the consequences.

 

[red floyd]

[redacted]
Some people use the first form because in that case typing "=" instead
of "==" by accident will produce a syntax error that the compiler will
catch.

Also because people take MS samples as gospel.