Multiple for loops with different conditions [closed] - c++

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 4 years ago.
Improve this question
I am trying to find an element in an array/list with some strict conditions. I try to find the element again with relaxed conditions if none of the elements satisfy the strict conditions.
for( ele : list) {
if(con1 && cond2 && cond3) {
return ele;
}
}
for( ele : list) {
if(con1 && cond2) {
return ele;
}
}
.....
Should I add a for loop with relaxed conditions each time? Is there a better way?
Better means less coding and good code readability.

Answer 1

Basic answer
I guess this all depends heavily on how many conditions there are and how complex they are. If it's only three separate conditions then yes, I would write something similar to your code. It's simple and easy to read and maintain.
In more complex situations
If there are many more conditions (like 10 or so) or you anticipate there will be more that needs to be added, you might consider using lambdas together with a vector instead:
// sample conditions for integers. Most strict condition is
// an even integer greater than 2 and less than 10
const std::vector<std::function<bool(int)>> conditions{
[](int elem) {return elem < 10;},
[](int elem) {return elem > 2;},
[](int elem) {return elem % 2 == 0;}
// add as many more conditions you wish...
// top condition is the one that will be relaxed first
};
// This will bit-by bit relax the conditions by ignoring more and more of them
auto start_iterator = conditions.begin();
while (start_iterator != conditions.end())
{
for (const auto& elem : list)
{
bool fulfills_all = std::all_of(start_iterator, conditions.end(), [] (std::function<bool(int)> cond) {
// for each active condition, test the condition on the element
return cond(elem);
});
if (fulfills_all)
return elem;
}
// If we get here, that means no element fulfilled all the conditions.
// Relax them by ignoring one more
start_iterator++;
}
// If we reach this point, then no element fulfilled even the most relaxed condition
Haven't really tested this, so some syntax may be a bit rusty but the general idea of it should work. The use of lambdas in std::function wrappers in a vector allow for a large number of conditions only having to be coded once, and std::all_of allows us to iterate over many conditions and verify that each of them are fulfilled for a certain element.
This requires the <functional> and <algorithm> headers.
If you are unfamiliar with std::function or std::any_of then these are helpful sites:
http://en.cppreference.com/w/cpp/utility/functional/function
http://en.cppreference.com/w/cpp/algorithm/all_any_none_of

Answer 2

Your description is pretty ambiguous, but I suspect you're looking for something like (incomplete pseudo-code).
// assuming the relaxed conditions are a subset of the strict conditions
whatever_type relaxed_return_value;
bool relaxed_found = false;
for (auto &element : some_list)
{
if (cond1 && cond2) // check relaxed conditions first
{
if (cond3) // check remaining strict conditions
{
return element; // return immediately on matching strict conditions
}
else if (!relaxed_found)
{
relaxed_return_value = element;
relaxed_found = true;
}
}
}
if (relaxed_found)
return relaxed_return_value;
else
indicate_no_value_found();
The above returns immediately if an element is found that matches the strict conditions, otherwise keeps going and keeps track of the first element that matches the relaxed conditions. If the loop completes, there has been no element matching the strict conditions, and the first result matching relaxed conditions (if any) is identified.
If there is a value of whatever_type (i.e. of an element) that can indicate no data (e.g. it's a pointer and NULL indicates it points at nothing) the logic can be simplified from the above (e.g. no need for bool value to keep track of whether a result has been found for relaxed criteria).
As to whether this is "better", that is completely subjective. Main advantage of this approach over two loops is that no tests will be repeated if no elements meet strict requirements. The downside is additional book-keeping to keep track of the first match of relaxed tests until all elements have been checked against strict criteria.