C++ Strange behaviour for comparison with XOR value

Question

Let's take the following program (called charco.cpp and intentionally starts with //):

//
#include <iostream>
#include <stdio.h>
int main()
{
    FILE* fp = fopen("charco.cpp", "rt");
    char c = fgetc(fp);
    if(c == '/')
    {
        char c2 = fgetc(fp);
        if(c2 == 122^85) // *** OK
        {
            c2 = fgetc(fp);
            while(c2 != 246^252)  // **** NOT OK
            {
                c2 = fgetc(fp);
            }
        }
    }
}

In its current incarnation it will loop forever in the line indicated with **** NOT OK, because it will fail to match the endline character after the // so it reads the entire file...

However, if I change 246 ^ 252 to 10, (char)(246 ^ 252) or just simply '\n' it does not loop forever anymore, it matches correctly, but (char)246^252 fails again.

Can anyone explain me why is this strange behaviour? (compiler: g++ 4.9.2)

@Borgleader: [If he's compiling it with a C++ compiler, it's C++](http://meta.stackoverflow.com/a/281387/560648). Not very good C++, but C++. — Lightness Races in Orbit, Feb 24 '15 at 14:42
@fritzone: What on earth are you trying to do? Can you abstract away all this "reading self into a `FILE`" gubbins and just show us some inputs and outputs to the XOR operator that you think are wrong? — Lightness Races in Orbit, Feb 24 '15 at 14:43
Agree with @LightnessRacesinOrbit. Just capture the value of `c2`, and then construct a test case around that. — Oliver Charlesworth, Feb 24 '15 at 14:44
Note that [`fgetc`](http://en.cppreference.com/w/c/io/fgetc) returns an ***`int`***. Also note that the mode `"rt"` argument to [`fopen`](http://en.cppreference.com/w/c/io/fopen) is non-standard. — Some programmer dude, Feb 24 '15 at 14:44
reading "self" is just that everyone has a "file", it could be basically every source file — Ferenc Deak, Feb 24 '15 at 14:45
@LightnessRacesinOrbit Remember that game for children with different shaped holes? What you said basically amounts to: "If the square fits in the circular hole, it's a circle." — Borgleader, Feb 24 '15 at 14:45
@ScottStensland What do you mean "raising"? That's the xor operator. — Some programmer dude, Feb 24 '15 at 14:46
@JoachimPileborg : That's where I think the problem is ... I just can't nail it down right now ... — Ferenc Deak, Feb 24 '15 at 14:46
I reference this page: http://en.cppreference.com/w/cpp/language/operator_precedence when I have doubts about precedence (or just include the parens to be safe.) — Dale Wilson, Feb 24 '15 at 14:51
== has higher operator precedence than ^, simple as that. `(c2 == 122) ^ 85` doesn't make any sense. — Lundin, Feb 24 '15 at 14:51
When working with XOR, I prefer to use hexadecimal literals (instead of decimal literals). It makes it easy to visualize the bit pattern. — Cole Tobin, Feb 24 '15 at 15:06

score 16 · Accepted Answer · answered Feb 24 '15 at 14:46

16

while (c2 != 246^252)

You are doing:

while ((c2 != 246)^252) // Fail, bool^252

if c2 != 246, this will give 253 (0^252). Otherwise will give 252.

You have to use parenthesis :-)

while (c2 != (246^252)) // Correct, c2 != 10

answered Feb 24 '15 at 14:46

amchacon

1,891
1
18
29

For reference (to the OP) see e.g. [this operator precedence table](http://en.cppreference.com/w/cpp/language/operator_precedence). – Some programmer dude Feb 24 '15 at 14:48
[Here's an attempt](http://stackoverflow.com/questions/17369090/operator-precedence-table) I once made of a C11 precedence table. – Lundin Feb 24 '15 at 14:54
Yup ... This also explain why `(c2 == 122^85)` although that it gives a very weird value is executed correctly ... – Ferenc Deak Feb 24 '15 at 14:54
@Lundin I'll print it and stick it on the wall as reminder of this day .. and actually I have looked at the operator precedence table ... just didn't spot the spot :( – Ferenc Deak Feb 24 '15 at 14:57
@fritzone Only true C nerds know the operator precedence of every single operator in the language :) Which is why an extra parenthesis is always encouraged as good programming practice. Even if _you_ know the operator precedence of some particular operators, the person reading your code may not. Even the creator of the C language [recognized early on](http://www.lysator.liu.se/c/dmr-on-or.html) that the operator precedence of == would be a cause of trouble. It is kind of a design flaw of C. – Lundin Feb 24 '15 at 15:08

score 5 · Answer 2 · edited May 23 '17 at 11:56

5

For historical reasons, the bitwise operators have a weird operator precedence.

You have to use parentheses to enforce the correct order:

while (c2 != (246^252))

In fact, I strongly recommend using parentheses all the time when you use these operators.

Here's a minimal example to show the difference:

cout << (1 == 1 ^ 2) << " " << (1 == (1 ^ 2)); 
// 3 0

edited May 23 '17 at 11:56

Community

1
1

answered Feb 24 '15 at 14:49

Karoly Horvath

94,607
11
117
176

I'd like to see those historical reasons :) – Ferenc Deak Feb 24 '15 at 14:55
1

I'm just trying to find a good article.. basically initially the bitwise operators were used for logic operators and the actual logical operators were added later to the language, but by that time they wouldn't want to fix the precedence - too much code was relying on the precedence order. – Karoly Horvath Feb 24 '15 at 14:57

C++ Strange behaviour for comparison with XOR value

2 Answers2