使用自己的类和std::的“运算符==”的模糊重载string_view

Question

我在＜code＞命名空间N。

namespace N
{
class MyClass
{
// member function begin()
// member function end()
// content omitted
}

template<typename T>
bool operator==(const MyClass& a_mc, const T& a_other)
{
    using namespace std;
    return std::equal(a_mc.begin(), a_mc.end(), begin(a_other));
}
}

这会导致其他代码无法编译（从堆栈中包含，省略）：

错误：'operator=='的不明确重载（操作数类型为'std：：basic_string_view'和'const char [3]'）

注意：候选：'bool N::运算符==（const N::MyClass

备注：候选者：'constexr bool std::运算符==（std::basic_string_view

为什么还要考虑 N：：operator==？

-

编辑遇到问题的第一个代码是

bool N::MyClass::f(const std::string_view& a_thing)
{return a_thing.substr(0,2) == "XY";}

--

最小工作示例：

#include <algorithm>
#include <string_view>
#include <type_traits>

namespace N
{
        struct MyClass
        {
                MyClass() noexcept = default;
                template<typename T,
                        typename = std::void_t<decltype(T{}.data())>,
                        typename = std::void_t<decltype(T{}.size())>>
                MyClass(const T& a_source)
                {}

                const char* begin() const { return 0; } // stub
                const char* end() const { return 0; } // stub
                bool f(const std::string_view& a_thing);
        };

        template<typename T>
        bool operator==(const MyClass& a_mc, const T& a_other)
        {
            using namespace std;
            return std::equal(a_mc.begin(), a_mc.end(), begin(a_other));
        }

        bool MyClass::f(const std::string_view& a_thing)
        {
                return a_thing.substr(0,2) == "XY";
        }
}

编译方式

g-std=c 17example.cpp

Answer 1

MyClass 有一个与 std：：string_view 一起使用的模板构造函数。

由于构造函数未标记为显式，因此允许编译器将其用于隐式转换。

这意味着当您这样做时

bool N::MyClass::f(const std::string_view& a_thing)
{return a_thing.substr(0,2) == "XY";}

允许编译器将＜code＞转换为_thing。substr（0,2）到一个＜code＞MyClass。

避免此类情况的一种方法是使 MyClass 的构造函数显式化。

template<typename T,
    typename = std::void_t<decltype(T{}.data())>,
    typename = std::void_t<decltype(T{}.size())>>
    explicit MyClass(const T& a_source)
    {}