do while loops with &&

[avi123]

Hi,

Can I do something like this:

X *pX;

do
{
//.....
}while((pX != NULL) && (pX->func() >2))

I mean can I be sure that the left condition pX!= NULL, will be checked before the right condition (pX->func() >2), hence if the right condition will be checked only if the left condition is true?

Thanks
Avi123

[Krishnaa]

Yes, if pX is checked for NULL in brackets first then it will be executed first, being an AND openration both conditions will be checked always.

But if you want to make it sure and remove compiler dependancies then you shold have do those check before using while as follows,

X *pX;

do
{
//.....

bool bX = (pX != NULL) ;
bX = bX && (pX->func() >2) ;

}while(bX)

[irs_b]

X *pX;

First of all you need to allocate memory to pX ..

And the code you wrote is best option to check for NULL first.

regards

[avi123]

Thank you both for your quick response
However I still not sure,

Krishnaa: you say that the left side will be calulated first, however then you say that in order not to depend on compiler, are there any compilers that may calculate the right side before the left side

irs_b: when you say best option, is this the only option or is there might be compiler that will check the right side first?

Thanks again
Avi123

[Philip Nicoletti]

When using && ...

Left-to-right evaluation is guaranteed and the second operand is
not evaluated if the first operand is false.

[avi123]

Thanks Philip,

Are there any other operators where left to right order is not guaranteed?

Thanks
Avi123

[irs_b]

You can get the associativity of all operators below link

C++ operator precedence

[MikeAThon]

When using && ...

Left-to-right evaluation is guaranteed and the second operand is
not evaluated if the first operand is false.

Just to emphasize the point, this is guaranteed by the language, and is not compiler-dependent. Every compiler out there will conform on this point.

Mike

[TheCPUWizard]

Actually the built in "&&" and "||" operators will short circuit.

For &&, if the first is falst the second is not evaluated.
For ||, if the first ie true, the second is not evaluated.

However if you overload the operator then both are evaluated under all conditions (hence the recommendation to never overload these operators!)

[kyoryu]

That type of check is extremely common in production code.

I've also seen it frequently abbreviated as:

Thing *ptr;
if(ptr && ptr->foo())
...

though some might argue that the form 'if(ptr)' is a poor coding standard.

[TheCPUWizard]

And as soon as someone writes

template<class RHS_TYPE>
bool Thing::operator &&(Thing const &lhs,  RHS_TYPEconst&rhs);

It Immediately Breaks!

[laserlight]

But as your pointed out, it is not recommended to overload operator&& anyway....

[TheCPUWizard]

And I also tend to be paranoid...

Even if I don't overload, how can I guarantee 100% that some vendor will not change their implementation at some point and implement the overload.