How to use default spaceship operator with a std::string member - c++

Question

I have a struct with a few POD types and one string member. I want to use the default spaceship operator to allow equality operations of my struct, but I'm having some issues with the string member. As far as I can tell, there should be support for <=> for std::string, but in practice it seems like this isn't the case.
I have a minimal reproducing example, and the resulting warning that I get from clang (version 14) below. Strangely, in godbolt this example produces no warning/error, even going as far back as clang 12 (https://godbolt.org/z/b65s9oMGf).
I'd really appreciate some pointers in where my misunderstanding is, because I'm pretty confused about this one.
#include <compare>
#include <string>
enum class MyEnum
{
ZERO = 0,
ONE = 1
};
struct MyStruct
{
float a{};
int b{};
std::string c{};
MyEnum d{};
auto operator<=>(const MyStruct&) const = default;
};
int main()
{
MyStruct my_struct;
MyStruct my_other_struct;
if(my_struct == my_other_struct)
{
return 0;
}
return 1;
}
$ clang --std=c++20 -Werror test.cpp
test.cpp:16:10: error: explicitly defaulted three-way comparison operator is implicitly deleted [-Werror,-Wdefaulted-function-deleted]
auto operator<=>(const MyStruct&) const = default;
^
test.cpp:13:17: note: defaulted 'operator<=>' is implicitly deleted because there is no viable three-way comparison function for member 'c'
std::string c{};
^
1 error generated.
$ clang --version
Apple clang version 14.0.0 (clang-1400.0.29.202)

Answer 1

Based on the comments, it appears that this version of clang along with its standard library:
does implement the language feature for <=>, but
does not yet implement the library additions for <=> (specifically adding <=> for std::string).
When you write:
struct MyStruct
{
float a{};
int b{};
std::string c{};
MyEnum d{};
auto operator<=>(const MyStruct&) const = default;
};
What a defaulted <=> means is to do a member-wise comparison using <=>, returning the value for the first member that compares unequal. When you use auto, that is asking the compiler to deduce the comparison category for you - but unlike typical use of auto (where all the return types have to be the same, and auto deduces to that one type), here we take the minimum of all the comparison categories. For example, if we had one member whose <=> returned weak_ordering but another whose <=> returned strong_ordering, a defaulted <=> would return weak_ordering (rather than not compile). Basically - it does what you probably want it to do, in the way you'd expect.
But - sometimes defaulting <=> isn't sufficient, if one of your members don't actually provide <=> yet (as in this case). In that situation, it'd be tedious to have to manually write all the comparisons out. So for that reason, there's another way that you can default <=> (from P1186): you can explicitly provide a comparison category:
struct MyStruct
{
float a{};
int b{};
std::string c{};
MyEnum d{};
std::strong_ordering operator<=>(const MyStruct&) const = default;
};
What this means is, rather than simply doing member-wise <=>, we do something a little more involved:
if the member has <=>, use it. And it has to meet the comparison category requirement (in this case, it would happen to fail because floats compare with partial_ordering, which doesn't meet the strong_ordering requirement - so it would have to return partial_ordering).
if the member doesn't provide <=>, we synthesize a three-way comparison from == and <.
So in this case:
struct MyStruct
{
float a{};
int b{};
std::string c{};
MyEnum d{};
std::partial_ordering operator<=>(const MyStruct&) const = default;
};
would behave like:
std::partial_ordering operator<=>(const MyStruct& rhs) const {
// a and b provide <=>, so use it
if (auto cmp = a <=> rhs.a; cmp != 0) return cmp;
if (auto cmp = b <=> rhs.b; cmp != 0) return cmp;
// c doesn't yet, so synthesize one
if (auto cmp =
(c == rhs.c ? partial_ordering::equivalent :
c < rhs.c ? partial_ordering::less :
c < rhs.c ? partial_ordering::greater :
partial_ordering::unordered); cmp != 0) return cmp;
// and d does, so use it
return d <=> rhs.d;
}
The advantage of this language feature (as I laid out in that paper) is that once std::string does provide <=>, your implementation will pick it up automatically and be more efficient (cause the above really isn't a great implementation for string, you'd want to do c.compare(rhs.c) <=> 0), without you having to do all the work yourself.