Thread: Multi-conditional if statements.

also, know that && (AND) is figured before || (OR)

for example: if(true && false || true) evaluates to true

there are also other operators, like the ! (NOT) operator. it simply negates the value. for example, if(!true) evaluates to false.

you can also use parenthesis. I assume you know how parenthesis mess with the order of operations in arithmetic, so all I'm going to say is it's essentially the same for logic.

be careful though

c++ uses short circuit evaluation

take for example

Code:

bool thisIsTrue = true;
if(thisIsTrue || ImportantFunction())
{
    .........
}

when it sees the || it knows that either the left operand (thisIsTrue) or the right operand (the return value of ImportantFunction()), must be true in order to execute the code within the if{} block. since "thisIsTrue" is in fact true, there is no need to evaluate the rest of the expression and does not call "ImportantFunction()".



don't get cute with that piece of information either and do

Code:

//bad
if(x || func())

in place of

Code:

//good
if(!x)
   func();

> if (0 == p)
Oddly, it seems easier to remember to use == than remember to swap the variables round.

Not only is p == 0 the natural way of reading it, because you've remembered that it should be == and not =, you DON'T have a problem when you try and do something like
if ( p == q )

Rearranging it to
if ( q == p )
doesn't help you because both can be assigned and your syntactic crutch to stop you falling over no longer works as it should.

In strings, can you make an if statement that looks to see if the user's input is contained in your criteria but isn't exactly your criteria?

Assuming you're talking about std::string and not char[]:

Code:

if(str.find("No") != std::string::npos)
   //it's contained.

Originally Posted by Thantos

NOT true. The order of evaluation is always left to right in a boolean statement. && binds the results tighter then ||.

So if you have:

Code:

if ( x==5 || y==2 && z==7)

the x==5 is evaluated before the rest of it.

I think you misunderstood what I meant. I meant that && has a higher precedence than ||. bad wording on my part. and a bad example as well. (thanks to skiingwiz for pointing that out). with that in mind, here's a better example:

if(false && true || true) evalutates to true
if((false && true) || true) evaluates to true
if(false && (true || false)) evaluates to false


C operator precedence:
http://msdn.microsoft.com/library/de...m/expre_13.asp

Still a bad example This also demonstrates the left-to-right evaluation order (evaluates the && first, because it is the leftmost operator).

**EDIT**
Hmm, I can't seem to come up with an example that will make a distinction between the two. Could it be that the two will always just give you the same result? In which case, the only real way to find out the order of evaluation would be to create bool functions that give output when they are called.

Originally Posted by Hunter2

Still a bad example This also demonstrates the left-to-right evaluation order (evaluates the && first, because it is the leftmost operator).

fine, how's this:

if(!(!A && B || A && !B))

jeebus... and 10 points to anybody whow knows what that gate's called.

edit: and another 20 points to the person who brings me the head of the person that gives me bad rep for trying to be helpful.

just a little note to circuit evaluation:
it makes it possible to write code like:

Code:

int *p;
/* code */
if(NULL != p && 1 == *p) {

}

without circuit evaluation (1 == *p) would be evaluated even though p could be NULL.