Is it defined behaviour to assign to function call in or in if (C++17)

Question

During a codebase refactor I found code like this:

void myFunction (std::map<int, int> my_map)
{
    int linked_element;
    if (my_map[linked_element = firstIndex] != 0
        || my_map[linked_element = secondIndex] != 0)
    {
        // do some stuff with linked_element
    }
}

Or

void myFunction (std::set<int> my_set)
{
    int linked_element;
    if (my_set.find(linked_element = firstIndex) != my_set.end()
        || my_set.find(linked_element = secondIndex) != my_set.end())
    {
        // do some stuff with linked_element
    }
}

From what I understood the aim of that was to avoid checking 2 times (first when entering in the if, second when assigning the variable). I can understand that depending on which side of the || is true linked_element will be assigned to the right value but this still feels kind of bad to me.

Is this kind of behaviour defined?

Answer 1

This behavior is well defined by the order of evaluation.

First, the linked_element = firstIndex assignment happens. This expression returns the value of firstIndex, that is then used as an argument for the subscript operator on my_map (i.e., my_map[linked_element = firstIndex]). The return value from that expression is checked against the != 0 condition. If it's true, the other side of the || operator is not evaluated due to short-circuit logic. If it's false, the same story happens on the other side of the operator.

Whether or not it's a good practice to write code in such a style is a different question though. Personally speaking, I'd prioritize readability and maintainability over this micro-optimization unless it's a super-critical piece of the program, but it's a matter of opinion, I guess.