Ambiguous overload for 'operator==' with own class and std::string_view

Question

I created a class named MyClass in namespace N. Now I define a global operator== in namespace 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));
}
}

This results in other code failing to compile with (included-from-stack omitted):

error: ambiguous overload for 'operator==' (operand types are 'std::basic_string_view' and 'const char [3]')

note: candidate: 'bool N::operator==(const N::MyClass&, const T&) [with T = char [3]]'

note: candidate: 'constexpr bool std::operator==(std::basic_string_view<_CharT, _Traits>, std::__detail::__idt >) [with _CharT = char; _Traits = std::char_traits; std::__detail::__idt > = std::basic_string_view]' 479 |
operator==(basic_string_view<_CharT, _Traits> __x

Why is N::operator== even considered?

--

Edit first code that hit the problem was

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

--

Minimal working example:

#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";
        }
}

Compile with

g++ -std=c++17 example.cpp

N::operator== is considered for what? please provide a minimal reproducible example. — 463035818_is_not_an_ai
– 463035818_is_not_an_ai, Commented Jan 15, 2020 at 18:33
we need a complete reproducible example. I do know what code I have to add to get a similar error, but I have no clue what code you have, so it is impossible to answer in a meaningful way — 463035818_is_not_an_ai
– 463035818_is_not_an_ai, Commented Jan 15, 2020 at 18:38
using namespace std; return std::equal(...); Pretty meaningless, isn't it? Normally you'd have using std::equal; return equal(...);. — Aconcagua
– Aconcagua, Commented Jan 15, 2020 at 18:55

super · Accepted Answer · 2020-01-15 19:05:22Z

2

MyClass has a template constructor that works with std::string_view.

Since the constructor is not marked explicit the compiler is allowed to use it for implicit conversions.

That means that when you do

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

the compiler is allowed to convert a_thing.substr(0,2) to a MyClass and then it could be used to call your bool operator==.

One way to avoid things like this is to make the constructor of MyClass explicit.

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

answered Jan 15, 2020 at 19:05

super

13k2 gold badges21 silver badges34 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

std_unordered_map Over a year ago

Why does the error message state that the operand types are 'std::basic_string_view' and 'const char [3]'?

super Over a year ago

The left-hand-side is a std::string_view and the right hand side is "XY" which get deduces as const char [3] by the template.

super Over a year ago

@std_unordered_map Another way to put it is that if your operator== did not exist "XY" would be converted to a std::string_view. But since both that and your operator== requires 1 conversion to work it is ambiguous which one should be preferred.

Collectives™ on Stack Overflow

Ambiguous overload for 'operator==' with own class and std::string_view

1 Answer 1

3 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Related