What is the meaning of NULL != value in C++? [duplicate]

This question already has answers here: Closed 11 years ago.

Possible Duplicate:

What is the difference between these (bCondition == NULL) and (NULL==bCondition)?

I was going through a piece of C++ code and came across a code like

if (NULL != threadInfo)
{
  ...
  ...
}

I was just wondering is there any difference between using the expression

if (threadInfo != NULL)
{
  ...
  ...
}

what is said above. While reading the first one reads " If NULL not equals to ThreadInfo" and the second one reads "If threadInfo not equals to NULL". To me the second one makes 开发者_开发百科more sense.

---

No, there is no difference. In case of == there might be some difference. The thing is that if you accidentally write = instead of == the compiler will give an error in the first case.

if (threadInfo = NULL) //always false. The compiler will give you a warning at best

if (NULL = threadInfo) //Compiler error

I personally hate that practice and think it's better to write code that can be read in a normal human language, not Yoda language.

---

It's for safety, so you don't accidentally write

threadInfo = NULL

instead of

threadInfo == NULL

For the != there's no need to do this, but it's consistent.

---

If threadInfo is of a type that overrides operator !=, and the owner of that class has not provided a symmetric free function that handles the case where the two arguments are swapped, there might be a difference (there might also be a need to fire that programmer).

Otherwise, it's a matter of taste. Probably it will be preferred by people who write if(42 == answer) instead of if(answer == 42) -- this protects you from mistyping an assignment operator instead of an equals check. But since modern compilers warn you when you do that, it's debatable whether this approach offers anything.

---

There is no difference. The point of writing NULL != ... is that if you instead make a typo and write NULL = ... the code won't compile. If you had ... = NULL it could be a valid assignment and the error could go unnoticed (but most compilers detect this and warn you). Somebody once tried to insert a backdoor into the Linux kernel using this technique.

Also note that most persons don't code like that.

---

There is no difference, EXCEPT that the first option cannot be mistyped as:

if (threadInfo = NULL)
{
    ...
    ...
}

And some people don't know how to use compiler switches to check this (and some compilers don't have them).

---

No difference, this is so called Yoda coding convention.

if (NULL != threadInfo)

is equivalent to

if (threadInfo != NULL)

and to

if (threadInfo)

---

This is usually used as a convention, and has no distinct meaning by itself.

Because assignment occurs to lvals, and NULL is unassignable, this protects against the dreaded threadInfo = NULL when you meant threadInfo == NULL or threadInfo != NULL bug.

For more detail, see this wikipedia article section on left-hand comparisons

---

Both do the same thing. It is a style convention that was used to avoid typing mistakes as:

if (value=NULL) // assignment instead of == operator 
{ 
}

---

These are exact equivalents in terms of logic.

The second is more intutive, when one may see the first is seen as more safe as it doesn't allows writing (threadInfo = NULL) erroneously, leading to a bug.

---

Null is a reference in the memory contains nothing but that nothing have an address to access it.

By that you can make a comparisons behind null to check if a certain object have a value or nothing.

---

I don't see any difference. However, the practice of writing NULL == someVar would save you from writing NULL = someVar if you forget typing the second =.