Is overloading logical operations considered good or bad practice?

This is generally considered bad practice.

Reasons:

• Unexpected behavior: Overloading && and || loses their short-circuit evaluation property. Both operands will always be evaluated, which can lead to side effects and performance issues.
• Loss of intuitiveness: Users expect standard boolean operator behavior. Overloading makes the code less readable and predictable.
• Debugging difficulties: Non-standard operator behavior complicates error detection.

Exceptions (rare cases):

• Types representing logical expressions: For example, in libraries for symbolic computations or logical circuits. In such cases, overloading may be justified for expression building.
• Domain-specific languages (DSLs): Sometimes overloading is used to create more expressive syntax in specialized fields.

Even in these rare cases, it is advisable to thoroughly document such behavior and consider alternatives (e.g., using named functions instead of operators).

It is much preferable to use named functions for operations that do not conform to standard boolean logic.

// Example of bad practice
class MyBool {
public:
    bool value;
    MyBool(bool v) : value(v) {}

    bool operator&&(const MyBool& other) const {
        // Both operands will be evaluated, even if this->value == false
        return value && other.value;
    }

    bool operator||(const MyBool& other) const {
        // Both operands will be evaluated, even if this->value == true
        return value || other.value;
    }
};

// Example of good practice (using named functions)
class SafeBool {
public:
    bool value;
    SafeBool(bool v) : value(v) {}

    bool and_op(const SafeBool& other) const {
        return value && other.value; // Short-circuit works on built-in bool type
    }

    bool or_op(const SafeBool& other) const {
        return value || other.value; // Short-circuit works on built-in bool type
    }
};