能否使用Lambda表达式重载运算符？以不可修改的struct X为例

Great question! The short answer is: you can't directly define a global operator== overload inside main() (C++ forbids defining functions inside other functions), but there are clever workarounds to get the behavior you want—local, scoped comparison logic that feels like using the == operator with your X struct.

Solution 1: Local Wrapper Class + Lambda #

This approach lets you use the == syntax while keeping all comparison logic confined to main(). We'll create a tiny wrapper class that wraps your X objects, and overload == for the wrapper to use your custom lambda logic.

#include <iostream>

// Your unmodifiable struct
struct X { int value; };

int main() {
    // Define your custom comparison logic as a lambda
    auto compare_x = [](const X& lhs, const X& rhs) {
        return lhs.value == rhs.value; // Adjust this to your needs!
    };

    // Local wrapper class—only accessible inside main()
    struct XWrapper {
        const X& ref;
        explicit XWrapper(const X& x) : ref(x) {}

        // Overload == to use our lambda
        friend bool operator==(const XWrapper& lhs, const XWrapper& rhs) {
            return compare_x(lhs.ref, rhs.ref);
        }

        // Optional: Overload != to reuse == logic
        friend bool operator!=(const XWrapper& lhs, const XWrapper& rhs) {
            return !(lhs == rhs);
        }
    };

    // Test it out!
    X a{10}, b{10}, c{20};
    if (XWrapper(a) == XWrapper(b)) {
        std::cout << "a equals b\n";
    }
    if (XWrapper(a) != XWrapper(c)) {
        std::cout << "a does not equal c\n";
    }
}

The wrapper is only visible inside main(), so your comparison logic won't leak to other parts of the program. The explicit constructor prevents accidental implicit conversions, keeping things safe.

Solution 2: Direct Lambda Comparison (Simpler, No == Syntax) #

If you don't strictly need to use the == operator symbol, this is the most straightforward approach. Just use your lambda directly for comparisons—no wrappers required, and the logic is completely scoped to main():

#include <iostream>

struct X { int value; };

int main() {
    // Define your comparison lambda
    auto is_x_equal = [](const X& lhs, const X& rhs) {
        return lhs.value == rhs.value;
    };

    X a{5}, b{5}, c{6};
    if (is_x_equal(a, b)) {
        std::cout << "a and b are equal\n";
    }
    if (!is_x_equal(a, c)) {
        std::cout << "a and c are not equal\n";
    }
}

Why Can't We Just Use a Lambda for operator== Directly? #

Lambda expressions in C++ are anonymous function objects—they aren't regular functions, and you can't bind them to a global operator overload. Plus, C++ doesn't allow defining any function (including operator overloads) inside another function like main(), which rules out a direct "local operator overload" approach.

内容的提问来源于stack exchange，提问作者Barmak Shemirani