Why doesn't constant expression give an error?

Question

If I initialized variable like this:

static int i = 2 * 2 / 0;

Then, compiler give me an error.

prog.c: In function 'main':
prog.c:5:23: warning: division by zero [-Wdiv-by-zero]
  static int i = 2 * 2 / 0; 
                       ^
prog.c:5:17: error: initializer element is not constant
  static int i = 2 * 2 / 0;

But, If I use || instead of *, like this:

static int i = 2 || 2 / 0;

then it's successfully compiled.

According to Operator Precedence, Precedence of * higher than ||. So, first 2 / 0 operation evaluated. Am I right?

So, why doesn't static int i = 2 || 2 / 0; give an error?

`||` is short circuiting, so the second part of the expression isn't evaluated at all. — vgru, Sep 04 '17 at 10:03
more interesting is to ask whether `a || 2 / 0` gives an error... — Antti Haapala -- Слава Україні, Sep 04 '17 at 10:09
@AnttiHaapala Maybe not for the division, but for the non-constant initialiser, — too honest for this site, Sep 04 '17 at 10:50
@AnttiHaapala: The question uses `static`, I assumed that too, of course. But the warning (it is not an error) is not mandated by the standard, div-zero is simply UB and at run-time it **typically** depends on whether the architecture generates an exception. FYI: gcc warns about `2 / 0` for `auto` variables, independent of the value of `a`, even without warning options. — too honest for this site, Sep 04 '17 at 11:37
Precedence only determines which operands are grouped with which operators - it *does not* determine order of evaluation. `||` and `&&` always evaluate left to right. — John Bode, Sep 04 '17 at 13:20

Bathsheba · Accepted Answer · 2017-09-04T12:05:57.853

5

It's due to the mandatory short-circuit evaluation of || and the fact that your expression is evaluated as

static int i = (2 || (2 / 0));

Because 2 is an expression equal to 2, 2 / 0 is not evaluated.

edited Sep 04 '17 at 12:05

answered Sep 04 '17 at 10:02

Bathsheba

231,907
34
361
483

1

And important detail is, `||` etc are *guaranteed* to be short-circuiting. – hyde Sep 04 '17 at 10:03

Why doesn't constant expression give an error?

1 Answers1