'const' 关键字改变语义

Question

I attempted today's leetcode challenge in C++. You have to find cousins in a binary tree. Here's my code.

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        this->x = x;
        this->y = y;
        return visit(overloaded{
            [](const bool& r) { 
                return r; 
            },
            [](const optional<int>& r) { 
                return false; 
            }
        }, helper(root));
    }

private:
    int x;
    int y;

    variant<const bool, optional<int>> helper(TreeNode* node) {
        if (node == nullptr) {
            return variant<const bool, optional<int>>((optional<int>()));
        }
        else if (node->val == x) {
            return variant<const bool, optional<int>>(optional<int>(0));
        }
        else if (node->val == y) {
            return variant<const bool, optional<int>>(optional<int>(0));
        }
        else {
            auto l = helper(node -> left);
            auto r = helper(node -> right);
            return visit(overloaded{
                [](const bool& l, optional<int>& r) {
                    assert(!r.has_value());
                    return variant<const bool, optional<int>>(l); 
                },
                [](optional<int>& l, const bool& r) {
                    assert(!l.has_value());
                    return variant<const bool, optional<int>>(r); 
                },
                [](optional<int> l, optional<int> r) {
                    if (l.has_value() && r.has_value()) {
                        return variant<const bool, optional<int>>(*l > 0 && *l == *r);
                    }
                    else if (l.has_value()) { 
                        ++*l;
                        return variant<const bool, optional<int>>(l); 
                    }
                    else if (r.has_value()) { 
                        ++*r;
                        return variant<const bool, optional<int>>(r); 
                    }
                    else {
                        return variant<const bool, optional<int>>((optional<int>())); 
                    }
                }
            }, l, r);
        }
    }
};

A testcase that demonstrates my issue is

[1,3,2,null,null,7,4,null,null,5,6,null,8,null,9]
8
9

The code above runs and completes successfully. However, if I remove a single const keyword in line 10 ( [](bool& r) { ) then it returns a different (incorrect) answer. const is for compile-time safety, so shouldn't affect semantics, but I guess something strange is happening with const overloading? What's going on exactly?

Possibly related: it also breaks my mental model that if, instead of declaring l , r in lines 34,35, I pass them directly as arguments to visit (ie. return visit(overloaded{..}, helper(node->left), helper(node->right) ), it also fails. I would again expect that to have no effect on semantics.

Answer 1

Removing the const in this case changes the meaning of the code, by changing which function is selected in overload resolution.

Consider the following overload set and call:

void f(int const &) { std::cout << "i"; }
void f(bool) { std::cout << "b"; }

int main()
{
    int const i = 42;
    f(i); // prints i
    f(42); // prints i
}

both call the first function (as expected), because a int const & binds to a int const , as well as int&& (a temporary int ).

However, if we remove the const in the first function of the overload set, and make the same call:

void f(int &) { std::cout << "i"; }
void f(bool) { std::cout << "b"; }

int main()
{
    int const i = 42;
    f(i); // prints b
    f(42); // prints b
}

the first function is not selected, because an int & , cannot bind to a int const . However, a bool can bind to an int const , (after an implicit conversion), and it calls the second function. Similarly, an int & cannot bind to a int&& , but a bool can, so it calls the second function.

This same reasoning applies to your example, but I've removed the variant , and custom overload set, as it simplifies the situation, without changing the underlying problem.