重载运算符| 干扰Qt枚举常量

Question

I made bit flags using a scoped enum, and I overload operator | to combine values:

enum class PARAM_T : int {
    NONE = 0x0,
    INPUT = 0x01,
    OUTPUT = 0x02,
    OUTPUT_VECTOR = 0x04
};

inline PARAM_T operator | (PARAM_T lhs, PARAM_T rhs)
{
    using T = std::underlying_type_t<PARAM_T>;
    return (PARAM_T)(static_cast<T>(lhs) | static_cast<T>(rhs));
}

Elsewhere in my project, I do some drag/drop operations using Qt widgets, where I use operator | to combine some named constants:

Qt::DropAction dropAction = drag->exec(Qt::CopyAction | Qt::MoveAction);

The operator | here is unrelated to my bit flags, yet for some reason my overload breaks this line of code, giving the following error:

error C2664: 'Qt::DropAction QDrag::exec(Qt::DropActions,Qt::DropAction)' : cannot convert argument 1 from 'int' to 'Qt::DropActions'

Why is the compiler matching Qt constants to my overload? They are entirely different and incompatible types.

Answer 1

Reading up on the subject of flags, I see that there are arguments against using enums as flags, so I changed my enum to this:

namespace PARAM {
    const int NONE =            0;
    const int INPUT =           1 << 0;
    const int OUTPUT_SCALAR =   1 << 1;
    const int OUTPUT_VECTOR =   1 << 2;
}

Now I can use the default implementations of operator | , operator & , etc, instead of my overloads, and Qt is happy again. This is more of a work-around than an answer; I'd still like to know why the compiler was using my overload for the Qt constants.