C++ logical & operator

Question

Is there a logical & operator in C++? e.g. an operator that works just as && except that it also evaluates later arguments even if some preceding ones have alrea

Answer 1

The operator & is indeed the bitwise operator. I'm assuming you have something like

if ( f() && g() ) { /*do something*/ }

and you want both f() and g() to execute, regardless of whether one of them was evaluated to false. I suggest you do something else instead:

bool bF = f();
bool bG = g();

if ( bF && bG ) { /*do something*/ }

This also provides better readability and doesn't confuse other programmers who try to maintain your code. In the long run, it's worth it.

Answer 2

There is no logical &, only a bitwise &.

if you want to avoid short-circuiting of logical statements, you need to use a proxy the won't be optimized away by the compiler to achieve it (such as a variadic meta-template).

Answer 3

There is no such "always execute" operator in C++.

My first inclination is that instead of looking for a new operator, you should re-evaluate what your methods do to eliminate any side effects that mandate they be executed. It may be possible in this way to simply be able to use && and be happy.

However if you actually want to do all the operations in sequence and then see if they all succeeded, probably Luchian Grigore's answer would be the best. It clearly delineates that it's sequential steps that always need to execute. There is one more option which may or may not be less clear:

// Each method needs to execute in sequence but we use "success" to track overall success. The order of operands to `operator&&` shouldn't be changed.
bool success = f1();
success = f2() && success;
success = f3() && success;

if(success) ...

Answer 4

If you overload the operator &&, it won't short circuit.

struct Bool {
  bool val;
  Bool(bool f): val(f) {}
  operator bool() {
    return val;    
  }
};


bool operator&&(Bool a, Bool b) {
  return (bool)a && (bool)b;
}

ref: point 19, section 13.9 in the C++ FAQ lite

Though as mentioned there, this is a very bad idea and confuses people. You might want to do it in a very limited way though if you have a very special case.