I tried the following code in Java

    t1 = 5;
    t2 = t1 + (++t1);
    System.out.println (t2);

My view is since ++ has a higher precedence than +, the above becomes

    t2 = t1 + (++t1);
    t2 = t1 + 6;      // t1 becomes 6 here
    t2 = 6 + 6;
    t2 = 12;

However, I get the answer 11 for t2. Can someone explain?



In Java, which gets executed first, &quot;+&quot; or &quot;++&quot;?

I like Scala&#39;s propose of operator precedence but in some rare cases, unmodified rules may be inconvenient, because you have restrictions in naming your methods. Are there ways to define another rules for a class/file, etc. in Scala? If not, would it be resolved in the future?


Operator precedence in Scala

What is the predefined order in which the clauses are executed in MySQL? Is some of it decided at run time, and is this order correct?

 - `FROM clause`
 - `WHERE clause` 
 - `GROUP BY clause`
 - `HAVING clause` 
 - `SELECT clause` 
 - `ORDER BY clause`

MySQL query / clause execution order

The following for loops produce identical results even though one uses post increment and the other pre-increment.

Here is the code:

    for(i=0; i&lt;5; i++) {
        printf(&quot;%d&quot;, i);
    }

    for(i=0; i&lt;5; ++i) {
        printf(&quot;%d&quot;, i);
    }

I get the same output for both &#39;for&#39; loops.  Am I missing something?

Post-increment and pre-increment within a &#39;for&#39; loop produce same output

Are the two statements below equivalent?

    SELECT [...]
    FROM [...]
    WHERE some_col in (1,2,3,4,5) AND some_other_expr

and

    SELECT [...]
    FROM [...]
    WHERE some_col in (1,2,3) or some_col in (4,5) AND some_other_expr

Is there some sort of truth table I could use to verify this?

SQL Logic Operator Precedence: And and Or

Consider the following example:

    class Quirky {
        public static void main(String[] args) {
            int x = 1;
            int y = 3;
    
            System.out.println(x == (x = y)); // false
            x = 1; // reset
            System.out.println((x = y) == x); // true
         }
    }

I&#39;m not sure if there is an item in the Java Language Specification that dictates loading the previous value of a variable for comparison with the right side (`x = y`) which, by the order implied by brackets, should be calculated first.

Why does the first expression evaluate to `false`, but the second evaluate to `true`? I would have expected `(x = y)` to be evaluated first, and then it would compare `x` with itself (`3`) and return `true`.

---
This question is different from https://stackoverflow.com/questions/32755655/order-of-evaluation-of-subexpressions-in-a-java-expression in that `x` is definitely not a &#39;subexpression&#39; here. It needs to be **loaded** for the comparison rather than to be &#39;evaluated&#39;. The question is Java-specific and the expression `x == (x = y)`, unlike far-fetched impractical constructs commonly crafted for tricky interview questions, came from a real project. It was supposed to be a one-line replacement for the compare-and-replace idiom

    int oldX = x;
    x = y;
    return oldX == y;

which, being even simpler than x86 CMPXCHG instruction, deserved a shorter expression in Java.

Why is x == (x = y) not the same as (x = y) == x?

    #include &lt;stdio.h&gt;

    int main(void)
    {
       int i = 0;
       i = i++ + ++i;
       printf(&quot;%d\n&quot;, i); // 3
    
       i = 1;
       i = (i++);
       printf(&quot;%d\n&quot;, i); // 2 Should be 1, no ?
    
       volatile int u = 0;
       u = u++ + ++u;
       printf(&quot;%d\n&quot;, u); // 1
    
       u = 1;
       u = (u++);
       printf(&quot;%d\n&quot;, u); // 2 Should also be one, no ?
    
       register int v = 0;
       v = v++ + ++v;
       printf(&quot;%d\n&quot;, v); // 3 (Should be the same as u ?)

       int w = 0;
       printf(&quot;%d %d\n&quot;, ++w, w); // shouldn&#39;t this print 1 1

       int x[2] = { 5, 8 }, y = 0;
       x[y] = y ++;
       printf(&quot;%d %d\n&quot;, x[0], x[1]); // shouldn&#39;t this print 0 8? or 5 0?
    }

    

Why are these constructs using pre and post-increment undefined behavior?

Does the ANSI standard *mandate* the logical operators to be short-circuited, in either C or C++?

I&#39;m confused for I recall the K&amp;R book saying your code shouldn&#39;t depend on these operations being short circuited, for they may not. Could someone please point out where in the standard it&#39;s said logic ops are always short-circuited? I&#39;m mostly interested on C++, an answer also for C would be great.

I also remember reading (can&#39;t remember where) that evaluation order isn&#39;t strictly defined, so your code shouldn&#39;t depend or assume functions within an expression would be executed in a specific order: by the end of a statement all referenced functions will have been called, but the compiler has freedom in selecting the most efficient order.

Does the standard indicate the evaluation order of this expression?

    if( functionA() &amp;&amp; functionB() &amp;&amp; functionC() ) cout&lt;&lt;&quot;Hello world&quot;;

Is short-circuiting logical operators mandated? And evaluation order?

When I was looking at answers to [this question](https://stackoverflow.com/questions/9201445/python-best-way-to-keep-track-of-results-from-loop), I found I didn&#39;t understand my own answer.

I don&#39;t really understand how this is being parsed. Why does the second example return False?

    &gt;&gt;&gt; 1 in [1,0]             # This is expected
    True
    &gt;&gt;&gt; 1 in [1,0] == True     # This is strange
    False
    &gt;&gt;&gt; (1 in [1,0]) == True   # This is what I wanted it to be
    True
    &gt;&gt;&gt; 1 in ([1,0] == True)   # But it&#39;s not just a precedence issue!
                               # It did not raise an exception on the second example.
    
    Traceback (most recent call last):
      File &quot;&lt;pyshell#4&gt;&quot;, line 1, in &lt;module&gt;
        1 in ([1,0] == True)
    TypeError: argument of type &#39;bool&#39; is not iterable

Thanks for any help. I think I must be missing something really obvious.

----

I think this is subtly different to the linked duplicate:

[Why does the expression 0 &lt; 0 == 0 return False in Python?](https://stackoverflow.com/questions/6074018/why-does-the-expression-0-0-0-return-false-in-python).

Both questions are to do with human comprehension of the expression. There seemed to be two ways (to my mind) of evaluating the expression. Of course neither were correct, but in my example, the last interpretation is impossible.

Looking at `0 &lt; 0 == 0` you could imagine each half being evaluated and making sense as an expression:

    &gt;&gt;&gt; (0 &lt; 0) == 0
    True
    &gt;&gt;&gt; 0 &lt; (0 == 0)
    True

So the link answers why this evaluates `False`:

    &gt;&gt;&gt; 0 &lt; 0 == 0
    False

But with my example `1 in ([1,0] == True)` doesn&#39;t make sense as an expression, so instead of there being two (admittedly wrong) possible interpretations, only one seems possible:

    &gt;&gt;&gt; (1 in [1,0]) == True

Why does (1 in [1,0] == True) evaluate to False?

Suppose I have a number of statements that I want to execute in
a fixed order. I want to use g++ with optimization level 2, so some
statements could be reordered. What tools does one have to enforce a certain ordering of statements?

Consider the following example.

    using Clock = std::chrono::high_resolution_clock;

    auto t1 = Clock::now(); // Statement 1
    foo();                  // Statement 2
    auto t2 = Clock::now(); // Statement 3

    auto elapsedTime = t2 - t1;

In this example it is important that the statements 1-3 are executed in
the given order. However, can&#39;t the compiler think statement 2 is
independent of 1 and 3 and execute the code as follows?

    using Clock=std::chrono::high_resolution_clock;

    foo();                  // Statement 2
    auto t1 = Clock::now(); // Statement 1
    auto t2 = Clock::now(); // Statement 3

    auto elapsedTime = t2 - t1;


Enforcing statement order in C++

In Python (I checked only with Python 3.6 but I believe it should hold for many of the previous versions as well):
 
    (0, 0) == 0, 0   # results in a two element tuple: (False, 0)
    0, 0 == (0, 0)   # results in a two element tuple: (0, False)
    (0, 0) == (0, 0) # results in a boolean True

But:
 
    a = 0, 0
    b = (0, 0)
    a == b # results in a boolean True

Why does the result differ between the two approaches? Does the equality operator handle tuples differently? 

Why in Python does &quot;0, 0 == (0, 0)&quot; equal &quot;(0, False)&quot;?

I&#39;m currently learning C++ with the book C++ Primer and one of the exercises in the book is:

&gt; Explain what the following expression does: `someValue ? ++x, ++y : --x, --y`

What do we know? We know that the ternary operator has a higher precedence than the comma operator. With binary operators this was quite easy to understand, but with the ternary operator I am struggling a bit. With binary operators &quot;having higher precedence&quot; means that we can use parentheses around the expression with higher precedence and it will not change the execution.

For the ternary operator I would do:

    (someValue ? ++x, ++y : --x, --y)

effectively resulting in the same code which does not help me in understanding how the compiler will group the code.

However, from testing with a C++ compiler I know that the expression compiles and I do not know what a `:` operator could stand for by itself. So the compiler seems to interpret the ternary operator correctly.

Then I executed the program in two ways:

    #include &lt;iostream&gt;
    
    int main()
    {
        bool someValue = true;
        int x = 10, y = 10;
        
        someValue ? ++x, ++y : --x, --y;
        
        std::cout &lt;&lt; x &lt;&lt; &quot; &quot; &lt;&lt; y &lt;&lt; std::endl;
        return 0;
    }

Results in:

    11 10

While on the other hand with `someValue = false` it prints:

    9 9

Why would the C++ compiler generate code that for the true-branch of the ternary operator only increments `x`, while for the false-branch of the ternary it decrements both `x` and `y`?

I even went as far as putting parentheses around the true-branch like this:

    someValue ? (++x, ++y) : --x, --y;

but it still results in `11 10`.

Why does the ternary operator with commas evaluate only one expression in the true case?

I cant seem to wrap my head around the first part of this code ( += ) in combination with the ternary operator.


    h.className += h.className ? &#39; error&#39; : &#39;error&#39;


  The way i think this code works is as following: 

    h.className = h.className + h.className ? &#39; error&#39; : &#39;error&#39;


But that isn&#39;t correct because that gives a error in my console.

So my question is how should i interpet this code correctly?

   





Operator precedence with Javascript Ternary operator

The output of this program:

    #include &lt;iostream&gt; 
    class c1
    {   
      public:
        c1&amp; meth1(int* ar) {
          std::cout &lt;&lt; &quot;method 1&quot; &lt;&lt; std::endl;
          *ar = 1;
          return *this;
        }
        void meth2(int ar)
        {
          std::cout &lt;&lt; &quot;method 2:&quot;&lt;&lt; ar &lt;&lt; std::endl;
        }
    };

    int main()
    {
      c1 c;
      int nu = 0;
      c.meth1(&amp;nu).meth2(nu);
    }

Is:

    method 1
    method 2:0

Why is `nu` not 1 when `meth2()` starts?

C++ execution order in method chaining

What are the implications of the voted in [C++17 evaluation order guarantees (P0145)](https://wg21.link/p0145) on typical C++ code? 

What does it change about things like the following? 

    i = 1;
    f(i++, i)

and

    std::cout &lt;&lt; f() &lt;&lt; f() &lt;&lt; f();

or 
    
    f(g(), h(), j());


What are the evaluation order guarantees introduced by C++17?

* If you execute `SELECT -100/-100*10` the result is `0`.
* If you execute `SELECT (-100/-100)*10` the result is `10`.
* If you execute `SELECT -100/(-100*10)` the result is `0`.
* If you execute `SELECT 100/100*10` the result is `10`.

[BOL](https://docs.microsoft.com/en-us/sql/t-sql/language-elements/operator-precedence-transact-sql?view=sql-server-2017) states:

&gt; When two operators in an expression have the same operator precedence level, they are evaluated left to right based on their position in the expression.

And

    Level	Operators
      1  	~ (Bitwise NOT)
      2 	* (Multiplication), / (Division), % (Modulus)
      3 	+ (Positive), - (Negative), + (Addition), + (Concatenation), - (Subtraction), &amp; (Bitwise AND), ^ (Bitwise Exclusive OR), | (Bitwise OR)

Is BOL wrong, or am I missing something? It seems the `-` is throwing the (expected) precedence off.

A strange operation problem in SQL Server: -100/-100*10 = 0

As far as I know, in C &amp; C++, the priority sequence for NOT AND &amp; OR is NOT&gt;AND&gt;OR. But this doesn&#39;t seem to work in a similar way in Python. I tried searching for it in the Python documentation and failed (Guess I&#39;m a little impatient.). Can someone clear this up for me?

Priority of the logical operators NOT, AND, OR in Python

If I do this:

    &gt;&gt;&gt; False in [False, True]
    True

That returns `True`. Simply because `False` is in the list.

But if I do:

    &gt;&gt;&gt; not(True) in [False, True]
    False

That returns `False`. Whereas `not(True)` is equal to `False`:

    &gt;&gt;&gt; not(True)
    False

Why?


Why does &quot;not(True) in [False, True]&quot; return False?

I was wondering about the order that a foreach loop in C# loops through a `System.Collections.Generic.List&lt;T&gt;` object.

I found [another question][1] about the same topic, but I do not feel that it answers my question to my satisfaction.

Someone states that no order is defined. But as someone else states, the order it traverses an array is fixed (from 0 to Length-1). [8.8.4 The foreach statement][2]

It was also said that the same holds for any standard classes with an order (e.g. `List&lt;T&gt;`).  I can not find any documentation to back that up. So for all I know it might work like that now, but maybe in the next .NET version it will be different (even though it might be unlikely). 

I have also looked at the [`List(t).Enumerator`][3] documentation without luck.

[Another related question][4] states that for Java, it is specifically mentioned in the documentation: 

&gt; `List.iterator()`returns an iterator over the elements in this list
&gt; in proper sequence.&quot;

 I am looking for something like that in the C# documentation.

Thanks in advance.

Edit: Thank you for all you for all your answers (amazing how fast I got so many replies). What I understand from all the answers is that `List&lt;T&gt;` does always iterate in the order of its indexing. But I still would like to see a clear peace of documentation stating this, similar to the [Java documentation on `List`][5].

  [1]: https://stackoverflow.com/questions/678162/sort-order-when-using-foreach-on-an-array-list-etc
  [2]: http://msdn.microsoft.com/en-us/library/aa664754(VS.71).aspx
  [3]: http://msdn.microsoft.com/en-us/library/x854yt9s.aspx
  [4]: https://stackoverflow.com/questions/1376934/java-for-each-loop-sort-order
  [5]: http://java.sun.com/javase/6/docs/api/java/util/List.html#iterator()


In what order does a C# for each loop iterate over a List&lt;T&gt;?

I&#39;ve come across a (seemingly) very strange case.

Take the number 2 (`0b10`) and bitmask it with 1 (`0b01`)

This should produce `0b00` which is equivalent to 0.

However, here&#39;s where Mr Schr&#246;dinger comes in:

    var_dump(0b10 &amp; 0b01); // int(0)
    var_dump(0b10 &amp; 0b01 == 0); // int(0)
    var_dump(0b10 &amp; 0b01 != 0); // int(0)

Whiskey. Tango. Foxtrot.

I am, admittedly, not the sharpest when it comes to bitwise operators - so maybe I&#39;ve got horribly, horribly wrong somewhere?

However, in Python:

`0b10 &amp; 0b01 == 0` = `True`

`0b10 &amp; 0b01 != 0` = `False`

...so?

Precedence and bitmask operations

In Bjarne Stroustrup&#39;s *[The C++ Programming Language][1]* 4th edition section `36.3.6` *STL-like Operations* the following code is used as an example of [chaining](http://en.wikipedia.org/wiki/Method_chaining):

    void f2()
    {
        std::string s = &quot;but I have heard it works even if you don&#39;t believe in it&quot; ;
        s.replace(0, 4, &quot;&quot; ).replace( s.find( &quot;even&quot; ), 4, &quot;only&quot; )
            .replace( s.find( &quot; don&#39;t&quot; ), 6, &quot;&quot; );

        assert( s == &quot;I have heard it works only if you believe in it&quot; ) ;
    }

The assert fails in `gcc` (*[see it live](http://coliru.stacked-crooked.com/a/d3d81ff98cab2f5c)*) and `Visual Studio` (*[see it live](http://rextester.com/IFNX5880)*), but it does not fail when using [Clang][2] (*[see it live](http://coliru.stacked-crooked.com/a/e6facaa9f18e252f)*).

Why am I getting different results? Are any of these compilers incorrectly evaluating the chaining expression or does this code exhibit some form of [unspecified](http://en.wikipedia.org/wiki/Unspecified_behavior) or [undefined behavior](http://en.wikipedia.org/wiki/Undefined_behavior)?

  [1]: https://en.wikipedia.org/wiki/The_C%2B%2B_Programming_Language
  [2]: http://en.wikipedia.org/wiki/Clang


Does this code from &quot;The C++ Programming Language&quot; 4th edition section 36.3.6 have well-defined behavior?

I am reading some Java text and got the following code:

    int[] a = {4,4};
    int b = 1;
    a[b] = b = 0;

In the text, the author did not give a clear explanation and the effect of the last line is: `a[1] = 0;`

I am not so sure that I understand: how did the evaluation happen?

What are the rules for evaluation order in Java?

This (note the **comma operator**):

    #include &lt;iostream&gt;
    int main() {
        int x;
        x = 2, 3;
        std::cout &lt;&lt; x &lt;&lt; &quot;\n&quot;;
        return 0;
    }

outputs **2**.

However, if you use `return` with the comma operator, this:

    #include &lt;iostream&gt;
    int f() { return 2, 3; }
    int main() {
        int x;
        x = f();
        std::cout &lt;&lt; x &lt;&lt; &quot;\n&quot;;
        return 0;
    }

outputs **3**.

Why is the comma operator behaving differently with `return`? 

Different behaviour of comma operator in C++ with return?

We get into unnecessary coding arguments at my work all-the-time. Today I asked if conditional AND (&amp;&amp;) or OR (||) had higher precedence. One of my coworkers insisted that they had the same precedence, I had doubts, so I looked it up. 

According to MSDN AND (&amp;&amp;) has higher precedence than OR (||). But, can you prove it to a skeptical coworker?
 
[http://msdn.microsoft.com/en-us/library/aa691323(VS.71).aspx][1]

    bool result = false || true &amp;&amp; false; // --&gt; false
    // is the same result as
    bool result = (false || true) &amp;&amp; false; // --&gt; false
    // even though I know that the first statement is evaluated as 
    bool result = false || (true &amp;&amp; false); // --&gt; false

So my question is how do you prove with code that AND (&amp;&amp;) has a higher precedence that OR (||)? If your answer is it doesn&#39;t matter, then why is it built that way in the language?

  [1]: http://msdn.microsoft.com/en-us/library/aa691323(VS.71).aspx

C# conditional AND (&amp;&amp;) OR (||) precedence

Given the following function call in `C`:

    fooFunc( barFunc(), bazFunc() );

The order of execution of `barFunc` and `BazFunc` is not specified, so `barFunc()` may be called before `bazFunc()` or `bazFunc()` before `barFunc()` in `C`. 

Does `Java` specify an order of execution of function argument expressions or like `C` is that unspecified? 

Order of execution of parameters guarantees in Java?

Let&#39;s take a simple example of an object `Cat`.  I want to be sure the &quot;not null&quot; `cat` is either orange or grey.

    if(cat != null &amp;&amp; cat.getColor() == &quot;orange&quot; || cat.getColor() == &quot;grey&quot;) {
    //do stuff
    }

I believe AND comes first, then the OR.  I&#39;m kinda fuzzy though, so here are my questions: 

1. Can someone walk me through this statement so I&#39;m sure I get what happens?

2. Also, what happens if I add parentheses; does that change the order of operations?

3. Will my order of operations change from language to language? 


In Java, what are the boolean &quot;order of operations&quot;?

When running the following line:

    &gt;&gt;&gt; [0xfor x in (1, 2, 3)]

I expected Python to return an error.

Instead, the REPL returns:

&gt; `[15]`

What can possibly be the reason?

Why does Python return [15] for [0xfor x in (1, 2, 3)]?

Trying to understand the behaviour of pointers in C, I was a little surprised by the following (example code below):

    #include &lt;stdio.h&gt;

    void add_one_v1(int *our_var_ptr)
    {
        *our_var_ptr = *our_var_ptr +1;
    }

    void add_one_v2(int *our_var_ptr)
    {
        *our_var_ptr++;
    }

    int main()
    {
        int testvar;

        testvar = 63;
        add_one_v1(&amp;(testvar));         /* Try first version of the function */
        printf(&quot;%d\n&quot;, testvar);        /* Prints out 64                     */
        printf(&quot;@ %p\n\n&quot;, &amp;(testvar));

        testvar = 63;
        add_one_v2(&amp;(testvar));         /* Try first version of the function */
        printf(&quot;%d\n&quot;, testvar);        /* Prints 63 ?                       */
        printf(&quot;@ %p\n&quot;, &amp;(testvar));   /* Address remains identical         */
    }

Output:

&lt;!-- language: lang-none --&gt;

    64
    @ 0xbf84c6b0

    63
    @ 0xbf84c6b0

What exactly does the `*our_var_ptr++` statement in the second function (`add_one_v2`) do since it&#39;s clearly not the same as `*our_var_ptr = *our_var_ptr +1`?


Post-increment on a dereferenced pointer?

If I try this:

    $a = 0;    
    echo $a + ++$a, PHP_EOL;
    echo $a;

I get this output:

    2
    1

Demo: http://codepad.org/ncVuJtJu

###Why is that?

I expect to get this as an output:

    1
    1

###My understanding:

    $a = 0;                    // a === 0    
    echo $a + ++$a, PHP_EOL;   // (0) + (0+1) === 1
    echo $a;                   // a === 1

But why isn&#39;t that the output?

Why is $a + ++$a == 2?

**Ruby**:

&lt;!-- language: lang-rb --&gt;

    true == true == true
&gt; syntax error, unexpected tEQ

vs. **JavaScript**:

&lt;!-- language: lang-js --&gt;

    true == true == true
    // =&gt; true

vs. **C**: 

&lt;!-- language: lang-c --&gt;

    1 == 1 == 1
    // =&gt; 1

Why does the expression (true == true == true) produce a syntax error?

I was figuring out how to do floor/ceiling operations without the `math` module. I solved this by using floor division `//`, and found out that the negative &quot;gives the ceiling&quot;. So this works:

```python
&gt;&gt;&gt; 3//2
1
&gt;&gt;&gt; -3//2
-2
```

I would like the answer to be positive, so first I tried `--3//2`, but this gives 1. I inferred this is because Python evaluates `--` to `+`. So to solve this, I found out I could use `-(-3//2))`, problem solved.

But I came over another solution to this, namely (I included the previous example for comparison):

```python
&gt;&gt;&gt; --3//2  # Does not give ceiling
1
&gt;&gt;&gt; 0--3//2  # Does give ceiling
2
```

I am unable to explain why including the 0 helps. I have read the documentation on division, but I did not find any help there. I thought it might be because of the evaluation order:

If I use `--3//2` as an example, from the documentation I have that `Positive, negative, bitwise NOT` is strictest in this example, and I guess this evaluates `--` to `+`. Next comes `Multiplication, division, remainder`, so I guess this is `+3//2` which evaluates to `1`, and we are finished. I am unable to infer it from the documentation why including `0` should change the result.

References:

- *[6.7. Binary arithmetic operations][1]*
- *[6.14. Evaluation order][2]*

  [1]: https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations
  [2]: https://docs.python.org/3.3/reference/expressions.html#evaluation-order








Why is there a difference between `0--3//2` and `--3//2`?

So, I&#39;m looking into writing a slightly more complex operation with logic operators in an if-else statement. I know I can do parentheses, and I know it&#39;s the better way of doing this, but I&#39;ve gotten curious and so I&#39;m going to ask. If I were to do something like this:

    if (firstRun == true || selectedCategory != undefined &amp;&amp; selectedState != undefined) {
    //Do something
    } else {
    //Do something else
    }

How will that be operated without the use of parentheses? I know there is an order of operations for logic operators, similar to PEMDAS, right? I&#39;m curious if it&#39;ll be ran something like this:

    firstRun == true || (selectedCategory != undefined &amp;&amp; selectedState != undefined)
or  maybe if the &#39;OR&#39; operator takes precedence instead and it ends up going like:

    (firstRun == true || selectedCategory != undefined) &amp;&amp; selectedState != undefined

The full list would be nice, if you can find it somewhere, of the order of operations for this. Thanks!

Which Logic Operator Takes Precedence

Okay, I&#39;m aware that the standard dictates that a C++ implementation may choose in which order arguments of a function are evaluated, but are there any implementations that actually &#39;take advantage&#39; of this in a scenario where it would actually affect the program?

Classic Example:

    int i = 0;
    foo(i++, i++);

Note: I&#39;m not looking for someone to tell me that the order of evaluation can&#39;t be relied on, I&#39;m well aware of that. I&#39;m only interested in whether any compilers actually do evaluate out of a left-to-right order because my guess would be that if they did lots of poorly written code would break (rightly so, but they would still probably complain).

Compilers and argument order of evaluation in C++

I have a codebase where developers decided to use `AND` and `OR` instead of `&amp;&amp;` and `||`.

I know that there is a difference in operators&#39; precedence (`&amp;&amp;` goes before `and`), but with the given framework ([PrestaShop][1] to be precise) it is clearly not a reason.

Which version are you using? Is `and` more readable than `&amp;&amp;`? Or is there no difference?

  [1]: https://en.wikipedia.org/wiki/PrestaShop


&#39;AND&#39; vs &#39;&amp;&amp;&#39; as operator

Here&#39;s a simple console application code, which returns a result I do not understand completely.

Try to think whether it outputs 0, 1 or 2 in console:

    using System;
    
    namespace ConsoleApplication
    {
        class Program
        {
            static void Main()
            {
                int i = 0;
                i += Increment(ref i);
    
                Console.WriteLine(i);
                Console.ReadLine();
            }
    
            static private int Increment(ref int i)
            {
                return i++;
            }
        }
    }


The answer is 0.

What I don&#39;t understand is why post increment `i++`, from the `Increment` method, which is executed on a `ref` (not on a copy of the passed variable) does increment the variable, but it just gets ignored later.

What I mean is in this video:

[![][1]][2]

Can somebody explain this example and why during debug I see that value is incremented to 1, but then it goes back to 0?


  [1]: https://i.stack.imgur.com/o0mWk.gif
  [2]: https://www.screencast.com/t/DkBvGmJv

All Operator Precedence Solutions on Gang of Coders

Total of 35 Operator Precedence Solutions

In Java, which gets executed first, "+" or "++"?