I'm currently learning C++ with the book C++ Primer and one of the exercises in the book is:

> 
> 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 "having higher precedence" 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 <iostream>

int main()
{
    bool someValue = true;
    int x = 10, y = 10;

    someValue ? ++x, ++y : --x, --y;

    std::cout << x << " " << y << 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`.