std :: tuple与多个空成员的比较不能在GCC上编译

Question

When there are multiple structures with no members in a tuple, trying to compile a comparison of tuples on GCC results in following error:

<source>: In function 'bool foo()':
<source>:120:16: error: request for member 'operator<' is ambiguous
  120 |     return a < b;
      |                ^
<source>:46:10: note: candidates are: 'bool N::operator<(const N&) const'
   46 |     bool operator<(const N &) const noexcept {
      |          ^~~~~~~~
<source>:46:10: note:                 'bool N::operator<(const N&) const'
Compiler returned: 1

Strangely enough, when I tie the same types I use in the tuple, it works as expected. One empty structure is also OK, two with different types are not.

Compilation with clang or msvc passes and yields expected results.

Is this correct behaviour, or is it a GCC/libstdc++ bug?

Demo

( Try it , uncomment the desired testcase first)

#include <tuple>

struct A {
    int value;
    A(int value) : value(value) {}

    bool operator==(const A &other) const noexcept {
        return value == other.value;
    }

    bool operator!=(const A &other) const noexcept {
        return value != other.value;
    }

    bool operator<(const A &other) const noexcept {
        return value < other.value;
    }
};

struct N {
    bool operator==(const N &) const noexcept {
        return true;
    }

    bool operator!=(const N &) const noexcept {
        return false;
    }

    bool operator<(const N &) const noexcept {
        return false;
    }
};

struct M {
    bool operator==(const M &) const noexcept {
        return true;
    }

    bool operator!=(const M &) const noexcept {
        return false;
    }

    bool operator<(const M &) const noexcept {
        return false;
    }
};



using AAKey = std::tuple<A, A>;
using ANAKey = std::tuple<A, N, A>;
using ANANKey = std::tuple<A, N, A, N>;
using ANAMKey = std::tuple<A, N, A, M>;
using NKey = std::tuple<N>;
using NNKey = std::tuple<N, N>;
using NMKey = std::tuple<N, M>;

bool foo() {
    /* Works
    AAKey a{0, 1};
    AAKey b{0, 0};
    //*/

    /* Works
    ANAKey a{0, N{}, 1};
    ANAKey b{0, N{}, 0};
    //*/

    /* Fails
    ANANKey a{0, N{}, 0, N{}};
    ANANKey b{0, N{}, 1, N{}};
    //*/

    /* Fails
    ANAMKey a{0, N{}, 0, M{}};
    ANAMKey b{0, N{}, 1, M{}};
    //*/


    /* Works
    NKey a{N{}};
    NKey b{N{}};
    //*/

    /* Fails
    NNKey a{N{}, N{}};
    NNKey b{N{}, N{}};
    //*/

    /* Fails
    NMKey a{N{}, M{}};
    NMKey b{N{}, M{}};
    //*/

    // Tying ANANKey into tuple:
    /* Works
    A ax1{0}, ay1{0}, ax2{0}, ay2{1};
    N nx1, ny1, nx2, ny2;
    auto a = std::tie(ax1, nx1, ax2, nx2);
    auto b = std::tie(ay1, ny1, ay2, ny2);
    //*/

    return a < b;
}

EDIT

Extenal operator overloads actually work (thanks to @Turtlefight):

#include <tuple>

struct O {
    friend bool operator==(const O &, const O &) noexcept {
        return true;
    }

    friend bool operator!=(const O &, const O &) noexcept {
        return false;
    }

    friend bool operator<(const O &, const O &) noexcept {
        return false;
    }
};

using OOKey = std::tuple<O, O>;

bool foo() {
    OOKey a{O{}, O{}};
    OOKey b{O{}, O{}};

    return a < b;
}

Answer 1

This is clearly a bug, in the sense that the standard doesn't give permission for the comparison to not work.

The cause is more interesting. libstdc++'s tuple is EBO'd in such a way that tuple<N> is actually derived from N if N is an empty class. When you do a < b we need to do a nonmember and a member lookup for operator< . The nonmember lookup finds tuple 's operator< as expected.

This member lookup, however, finds operator< in two different bases, so by [class.member.lookup]p6-7 this lookup produces an invalid set and is ill-formed on the spot.

Clang seems to accept this code by suppressing the error in the member lookup, but I'm not currently seeing anything in the standard that permits this behavior.