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

Question

We get into unnecessary coding arguments at my work all-the-time. Today I asked if conditional AND (&&) 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 (&&) 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

bool result = false || true && false; // --> false
// is the same result as
bool result = (false || true) && false; // --> false
// even though I know that the first statement is evaluated as 
bool result = false || (true && false); // --> false

So my question is how do you prove with code that AND (&&) has a higher precedence that OR (||)? If your answer is it doesn't matter, then why is it built that way in the language?

Answer 1

Wouldn't this get you what you're after? Or maybe I'm missing something...

bool result = true || false && false;

Answer 2

Change the first false by true. I know it seems stupid to have (true || true) but it proves your point.

bool result = true || true && false; // --> true 
result = (true || true) && false; // --> false
result = true || (true && false); // --> true

Answer 3

false || true && true

Yields: true

false && true || true

Yields: true

Answer 4

You don't prove it with code but with logic. AND is boolean multiplication whereas OR is boolean addition. Now which one has higher precedence?

Answer 5

There are two entities -- one tells the truth and the other always lies...

Answer 6

If you really want to freak him out try:

bool result = True() | False() && False();

Console.WriteLine("-----");
Console.WriteLine(result);

static bool True()
{
    Console.WriteLine(true);
    return true;
}

static bool False()
{
    Console.WriteLine(false);
    return false;
}

This will print:

True
False
False
-----
False

Edit:

In response to the comment:

In C#, | is a logical operator that performs the same boolean logic as ||, but does not short-circuit. Also in C#, the | operator has a higher precedence than both || and &&.

By printing out the values, you can see that if I used the typical || operator, only the first True would be printed - followed by the result of the expression which would have been True also.

But because of the higher precedence of |, the true | false is evaluated first (resulting in true) and then that result is &&ed with false to yield false.

I wasn't trying to show the order of evaluation, just the fact that the right half of the | was evaluated period when it normally wouldn't be :)

Answer 7

You cannot just show the end result when your boolean expressions are being short-circuited. Here's a snippet that settles your case.

It relies on implementing & and | operators used by && and ||, as stated in MSDN 7.11 Conditional logical operators

public static void Test()
{
    B t = new B(true);
    B f = new B(false);

    B result = f || t && f;

    Console.WriteLine("-----");
    Console.WriteLine(result);
}

public class B {
    bool val;
    public B(bool val) { this.val = val; }
    public static bool operator true(B b) { return b.val; }
    public static bool operator false(B b) { return !b.val; }
    public static B operator &(B lhs, B rhs) { 
        Console.WriteLine(lhs.ToString() + " & " + rhs.ToString());
        return new B(lhs.val & rhs.val); 
    }
    public static B operator |(B lhs, B rhs) { 
        Console.WriteLine(lhs.ToString() + " | " + rhs.ToString());
        return new B(lhs.val | rhs.val); 
    }
    public override string ToString() { 
        return val.ToString(); 
    }
}

The output should show that && is evaluated first before ||.

True & False
False | False
-----
False

For extra fun, try it with result = t || t && f and see what happens with short-circuiting.

Answer 8

We get into unnecessary coding arguments at my work all-the-time.

Well thats your problem. Being the right one is not as important as working together. The pragmatic solution is to use parenthesis to make it explicit.

Answer 9

We get into unnecessary coding arguments at my work all-the-time... If your answer is it doesn't matter, then why is it built that way in the language?

I always use parentheses to enforce precedence. But then that comes from my electrical engineering background. These 2 are different circuits:

result = (A || B) && C; 
result = A || (B && C);

And another reason that I put the parens in myself is that some of the code our company uses approaches 15 years old (we've got some shipping products that started life back then). You'll never know ahead of time if C# version 21.0 will have the same precedence that the current C# has. I'm old enough to remember when a "new" version of Forth came out that swapped the values of true and false: a heck of a lot of code quit working, and a heck of a lot of programmers changed languages. And a previous employer had several apps behave strangely when switching from one allegedly-standards-compliant C++ compiler to a different allegedly-standards-compliant C++ compiler only to find out that they actually didn't have the same rules of precedence.