Is compound if checking for null and then other condition in C always safe?

Question

(this question is an exact copy of Is compound if checking for null and then other condition in C++ always safe? but about C, not C++. It was pointed out that the question should be more specific).

I have been using the following type of if condition for a lot of time.

char* ptr = ...;
if (ptr != NULL && ptr[0] != '\0') // <=== is this always safe?
{ /* ... */ }

It relies on ptr != NULL being checked before ptr[0] !='\0'.

Is it safe under all standards, compilers, architectures? Or is there a possibility that ptr[0] != '\0' will be checked before ptr != NULL?

`&&` has associativity from Left to Right which means the Left expression is evaluated before the right one. — Sakthi Kumar, Feb 14 '14 at 10:24
@SakthiKumar: No, that's not at all what it means. Fortunately both things happen to be true. — Lightness Races in Orbit, Feb 14 '14 at 10:26
@SakthiKumar no, associativity does not affect the order of evaluation which is undefined in c++ (although not in the case for &&) — jcoder, Feb 14 '14 at 10:26
@LightnessRacesinOrbit I created a second question about C++, you are right, in C++ the problem is more complex. — Dariusz, Feb 14 '14 at 10:34
Sidenote: You could simplify that test to `if(ptr && *ptr)`, which may be more readable. — user694733, Feb 14 '14 at 10:56

user694733 · Answer 1 · 2014-02-14T10:36:23.743

13

Yes, it is safe.

C standard says (N1570 - 6.5.13 Logical AND operator):

Unlike the bitwise binary & operator, the && operator guarantees left-to-right evaluation; if the second operand is evaluated, there is a sequence point between the evaluations of the first and second operands. If the first operand compares equal to 0, the second operand is not evaluated.

edited Feb 14 '14 at 10:36

answered Feb 14 '14 at 10:24

user694733

15,208
2
42
68

2

+1 for quoting the standard :) – jcoder Feb 14 '14 at 10:25
3

+½ for quoting _one_ standard only – Lightness Races in Orbit Feb 14 '14 at 10:27
1

Consider moving your C++ answer to http://stackoverflow.com/questions/21776927/is-compound-if-checking-for-null-and-then-other-condition-in-c-always-safe – Dariusz Feb 14 '14 at 10:35
2

Maybe also add: "Yes" first. – starmole Feb 14 '14 at 10:35

score 2 · Answer 2 · answered Feb 14 '14 at 10:24

2

If ptr is a built in type then this is always safe. The compiler must evaluate the left hand side first and only evaluate the right hand side if the left side is true.

If ptr is a user defined type (which it isn't here) then this may not apply as operator&& can be overridden in the class and it DOES NOT short circuit like this.

answered Feb 14 '14 at 10:24

jcoder

29,554
19
87
130

1

@juanchopanza correct, that's why I said if ptr is a user defined type. That does not apply in the users code. I just wanted to make it clear to anyone reading the answer that your can't in general assume that && is short circuited without looking at the types involved. Feel free to improve the wording in the answer if its wrong or confusing. – jcoder Feb 14 '14 at 10:28
Ah OK, somehow I managed to read "pointer" in there. I will remove my comment. – juanchopanza Feb 14 '14 at 10:30
It doesn't only require you to overload `&&`, but also `!=`, to result in a type with overloaded `&&`. – Christian Rau Feb 14 '14 at 10:30
Ok the example here does of course. I just wanted to point out that in general be careful with && though... With a smart pointer don't write " if (sptr && sptr->data())" like you might with a raw pointer. – jcoder Feb 14 '14 at 11:35

score 1 · Answer 3 · answered Feb 14 '14 at 10:29

Yes its safe. It's called short-circuit evaluation and applies to the logical-and and logical-or operators.

In logical-and (&&) the right side is only evaluated if the left side is true.

In logical-or (||) the right side is only evaluated if the left side is false.

score 1 · Answer 4 · answered Feb 14 '14 at 10:31

1

The other answers already explain how short circuit evaluation guarantees that the code is safe - however, this only holds for a single thread.

If there are multiple threads executing the same code, and ptr is not using thread-local-storage, it may well be that in

ptr != NULL && ptr[0] != '\0')

You have a sequence like:

Thread 1 verifies that ptr != NULL is true.
Thread 2 assigns ptr = NULL
Thread 1 attempts to access ptr[0] and segfaults.

answered Feb 14 '14 at 10:31

Frerich Raabe

90,689
19
115
207

3

True, however this only applies if concurrent access to `ptr` is not protected. Such code I'd consider broken anyway. – alk Feb 14 '14 at 10:33

barak manos · Answer 5 · 2014-02-14T10:54:20.370

In your question, you write char* ptr = ....

So the answer depends on the context in which you assign ptr with a value.

As long as you assign ptr either with a valid memory address or with NULL, then it should be safe.

But if you assign ptr with an invalid memory address which is not NULL, then your code is unsafe.

For example:

char* ptr = func();

char* func()
{
    char* str; // possibly pointing to an invalid memory address which is not NULL
    return str;
}

Is compound if checking for null and then other condition in C always safe?

5 Answers5

Linked