How to handle multiple similar conditions in while loop? - c

Question

Sorry for the not so elusive title, but here is the piece of code I will use to explain my question!
while(motors[0].cycle <= maxcycle
&& motors[1].cycle <= maxcycle
&& motors[2].cycle <= maxcycle
&& motors[3].cycle <= maxcycle
&& motors[4], etc ...)
How can I avoid typing this very long condition for my while() loop, as I'm always checking the same parameter, only the index of my structure is changing.

Answer 1

How can I avoid typing this very long conditions, knowing that I'm always checking the same parameter, only the index of my structure is changing.
Add a function to do the checks and use the function in the while statement.
// MotorType is my contrived type. Use the right type.
bool doCheck(MotorType* motors, int count, int maxcycle)
{
for (int i = 0; i < count; ++i )
{
if ( !(motors[0].cycle <= maxcycle) )
{
return false;
}
}
return true;
}
while(doCheck(motors, count, maxcycle))
{
}

Answer 2

C++11 and above lets you fold the custom check function into a call of std::all_of using a lambda:
while (std::all_of(std::begin(motors), std::end(motors),
[=](Motor m){ return m.cycle < maxcycle; }))
{
...
Demo

Answer 3

Break it into a separate function and iterate through the array in the separate function and return true of it goes all the way through or false if it fails the if check.

Answer 4

You could do it in a loop:
while(true)
{
for(int i = 0, i < number, i++)
{
if (motors[i].cycle > maxcycle)
{
break;
}
}
//Do something
}

Answer 5

All the answers here which suggest an addition function do it... well, not neccessarily the best way. Here is why:
Since the loop is put into separate function, and the number of motors is not constant, compiler will most likely use the real loop and will not unroll it. Natural loops are a performance hazard when you counting nanoseconds.
However, original example didn't have that problem, as it didn't have a loop at all.
Solution: provide a function which would NOT use a loop at all, or make it easier for compiler to unroll it.

Answer 6

Abstract the condition into a method.
while ( allMotorsLessThanMax( motors, countMotors )) {
...
}
Then define that method with its own iteration:
bool allMotorsLessThanMax( Motor motors[], int countMotors ) {
for ( int i = 0; i < countMotors; ++i ) {
if ( maxcycle < motors[i].cycle ) {
return false;
}
}
return true;
}

Answer 7

Put it in a check in a lambda:
#include <algorithm>
...
void myFunction(){
auto allCycling = [&]() -> bool { // lambda function, capture by reference
return std::all_of( // for every element in the given range
motors.begin(), motors.end(), // given range is all of the motors container
[](const decltype(motors[0])& motor) -> bool {
return motor.cycle <= maxcycle; // check
});
while(allCycling()){
//do stuff
}
}
The capture by reference [&] for the lambda allows you to access all your function-wide variables in the lambda, without worrying about the costs of copying them.

Answer 8

I'll toss in the TMP version:
template < size_t I >
struct check_it
{
static bool call(motor_type * motors)
{
return check_it<I-1>::call(motors) && motors[I].cycles <= maxcycles;
}
}
template < >
struct check_it<0>
{
static bool call(motor_type * motors) { return motors[0].cycles <= maxcycles; }
};
while (check_it<42>::call(motors)) { ... }
Edit: I'm not necessarily recommending this, but it should optimize into exactly what you wrote. Hard to say if it's actually faster. Would depend on how many of the instructions are within the cache, etc... Maybe? You'd want to profile if it's important.