Melanggar perubahan dalam C ++ 20 atau regresi dalam dentang-trunk / gcc-trunk saat membebani perbandingan kesetaraan dengan nilai pengembalian non-Boolean?

Kode berikut mengkompilasi baik-baik saja dengan dentang-trunk dalam mode c ++ 17 tetapi istirahat dalam mode c ++ 2a (mendatang c ++ 20):

// Meta struct describing the result of a comparison
struct Meta {};

struct Foo {
    Meta operator==(const Foo&) {return Meta{};}
    Meta operator!=(const Foo&) {return Meta{};}
};

int main()
{
    Meta res = (Foo{} != Foo{});
}

Itu juga mengkompilasi dengan gcc-trunk atau clang-9.0.0: https://godbolt.org/z/8GGT78

Kesalahan dengan dentang-batang dan -std=c++2a:

<source>:12:19: error: use of overloaded operator '!=' is ambiguous (with operand types 'Foo' and 'Foo')
    Meta res = (f != g);
                ~ ^  ~
<source>:6:10: note: candidate function
    Meta operator!=(const Foo&) {return Meta{};}
         ^
<source>:5:10: note: candidate function
    Meta operator==(const Foo&) {return Meta{};}
         ^
<source>:5:10: note: candidate function (with reversed parameter order)

Saya mengerti bahwa C + + 20 akan memungkinkan untuk hanya kelebihan operator==dan kompiler akan secara otomatis menghasilkan operator!=dengan meniadakan hasil operator==. Sejauh yang saya mengerti, ini hanya berfungsi selama tipe kembalinya bool.

Sumber masalahnya adalah bahwa di Eigen kita mendeklarasikan satu set operator ==, !=, <, ... antara Arrayobjek atau Arraydan skalar, yang kembali (ekspresi) Array bool(yang kemudian dapat diakses elemen-bijaksana, atau digunakan jika ). Misalnya,

#include <Eigen/Core>
int main()
{
  Eigen::ArrayXd a(10);
  a.setRandom();
  return (a != 0.0).any();
}

Berbeda dengan contoh saya di atas ini bahkan gagal dengan gcc-trunk: https://godbolt.org/z/RWktKs . Saya belum berhasil menguranginya menjadi contoh non-Eigen, yang gagal di dentang-trunk dan gcc-trunk (contoh di atas cukup disederhanakan).

Laporan masalah terkait: https://gitlab.com/libeigen/eigen/issues/1833

Pertanyaan saya yang sebenarnya: Apakah ini benar-benar perubahan besar pada C ++ 20 (dan apakah ada kemungkinan untuk membebani operator pembanding untuk mengembalikan Meta-objek), atau apakah itu lebih cenderung berupa regresi dalam dentang / gcc?

Masalah Eigen tampaknya mengurangi sebagai berikut:

using Scalar = double;

template<class Derived>
struct Base {
    friend inline int operator==(const Scalar&, const Derived&) { return 1; }
    int operator!=(const Scalar&) const;
};

struct X : Base<X> {};

int main() {
    X{} != 0.0;
}

Dua kandidat untuk berekspresi adalah

1. kandidat yang ditulis ulang dari operator==(const Scalar&, const Derived&)
2. Base<X>::operator!=(const Scalar&) const

Per [over.match.funcs] / 4 , seperti operator!=yang tidak diimpor ke dalam lingkup Xdengan menggunakan-deklarasi , jenis parameter objek implisit untuk # 2 adalah const Base<X>&. Akibatnya, # 1 memiliki urutan konversi implisit yang lebih baik untuk argumen itu (kecocokan persis, daripada konversi yang diturunkan ke basis). Memilih # 1 kemudian menjadikan program tersebut salah bentuk.

Kemungkinan perbaikan:

• Tambahkan using Base::operator!=;ke Derived, atau
• Ubah operator==untuk mengambil const Base&alih - alih a const Derived&.

Ya, sebenarnya kode itu istirahat di C ++ 20.

Ekspresi Foo{} != Foo{}memiliki tiga kandidat dalam C ++ 20 (sedangkan hanya ada satu di C ++ 17):

Meta operator!=(Foo& /*this*/, const Foo&); // #1
Meta operator==(Foo& /*this*/, const Foo&); // #2
Meta operator==(const Foo&, Foo& /*this*/); // #3 - which is #2 reversed

Ini berasal dari aturan kandidat yang ditulis ulang di [over.match.oper] /3.4 . Semua kandidat itu layak, karena Fooargumen kami tidak const. Untuk menemukan kandidat yang terbaik, kita harus melalui tiebreak kita.

Aturan yang relevan untuk fungsi terbaik adalah dari [over.match.best] / 2 :

Mengingat definisi ini, fungsi layak F1didefinisikan sebagai fungsi yang lebih baik dari fungsi lain yang layak F2jika untuk semua argumen i, bukan urutan konversi lebih buruk dari , dan kemudian ICSi(F1)ICSi(F2)

• [... banyak kasus yang tidak relevan untuk contoh ini ...] atau, jika tidak, maka
• F2 adalah kandidat yang ditulis ulang ([over.match.oper]) dan F1 tidak
• F1 dan F2 adalah kandidat yang ditulis ulang, dan F2 adalah kandidat yang disintesis dengan urutan parameter terbalik dan F1 tidak

#2dan #3merupakan kandidat yang ditulis ulang, dan #3telah membalik urutan parameter, sementara #1tidak ditulis ulang. Tetapi untuk mencapai tiebreak itu, kita harus terlebih dahulu melewati kondisi awal itu: untuk semua argumen urutan konversi tidak lebih buruk.

#1lebih baik daripada #2karena semua urutan konversi adalah sama (sepele, karena parameter fungsi adalah sama) dan #2merupakan kandidat yang ditulis ulang sementara #1tidak.

Tapi ... keduanya berpasangan #1/ #3dan #2/ #3 terjebak pada kondisi pertama itu. Dalam kedua kasus, parameter pertama memiliki urutan konversi yang lebih baik untuk #1/ #2sedangkan parameter kedua memiliki urutan konversi yang lebih baik untuk #3(parameter yang constharus menjalani constkualifikasi tambahan , sehingga memiliki urutan konversi yang lebih buruk). Ini constflip-flop menyebabkan kita tidak dapat memilih satu baik.

Sebagai hasilnya, resolusi overload keseluruhan ambigu.

Sejauh yang saya mengerti, ini hanya berfungsi selama tipe kembalinya bool.

Itu tidak benar. Kami tanpa syarat mempertimbangkan kandidat yang ditulis ulang dan dibalik. Aturan yang kita miliki adalah, dari [over.match.oper] / 9 :

Jika operator==kandidat yang ditulis ulang dipilih dengan resolusi kelebihan untuk operator @, jenis kembalinya adalah cv bool

Artinya, kami masih mempertimbangkan kandidat ini. Tetapi jika kandidat terbaik yang layak adalah operator==yang mengembalikan, katakanlah, Meta- hasilnya pada dasarnya sama dengan jika kandidat itu dihapus.

Kami tidak ingin berada dalam keadaan di mana resolusi kelebihan harus mempertimbangkan jenis kembali. Dan dalam hal apapun, fakta bahwa kode di sini kembali Metatidak penting - masalahnya juga akan ada jika dikembalikan bool.

Untungnya, perbaikannya di sini mudah:

struct Foo {
    Meta operator==(const Foo&) const;
    Meta operator!=(const Foo&) const;
    //                         ^^^^^^
};

Setelah Anda membuat kedua operator pembanding const, tidak ada lagi ambiguitas. Semua parameter sama, sehingga semua urutan konversi sepele sama. #1sekarang akan dikalahkan #3oleh bukan oleh ditulis ulang dan #2sekarang akan dikalahkan #3dengan tidak terbalik - yang membuat #1kandidat terbaik. Hasil yang sama dengan yang kami miliki di C ++ 17, hanya beberapa langkah lagi untuk sampai ke sana.

[over.match.best] / 2 mencantumkan prioritas overload yang valid dalam satu set. Bagian 2.8 memberi tahu kita bahwa F1itu lebih baik daripada F2jika (di antara banyak hal lain):

F2adalah kandidat yang ditulis ulang ([over.match.oper]) dan F1tidak

Contoh di sana menunjukkan panggilan eksplisit operator<meskipun operator<=>ada di sana.

Dan [over.match.oper] /3.4.3 memberi tahu kita bahwa pencalonan operator==dalam keadaan ini adalah kandidat yang ditulis ulang.

Namun , operator Anda lupa satu hal penting: mereka harus constberfungsi. Dan membuatnya tidak constmenyebabkan aspek-aspek sebelumnya dari resolusi kelebihan beban ikut bermain. Fungsi tidak adalah sama persis, sebagai non const-to- constkonversi perlu terjadi untuk argumen yang berbeda. Itu menyebabkan ambiguitas yang dimaksud.

Setelah Anda membuatnya const, dentang kompilasi batang .

Saya tidak dapat berbicara dengan Eigen yang lain, karena saya tidak tahu kodenya, ini sangat besar, dan karenanya tidak dapat ditampung dalam MCVE.

Kami memiliki masalah serupa dengan file header Goopax kami. Kompilasi yang berikut dengan dentang-10 dan -std = c ++ 2a menghasilkan kesalahan kompiler.

template<typename T> class gpu_type;

using gpu_bool     = gpu_type<bool>;
using gpu_int      = gpu_type<int>;

template<typename T>
class gpu_type
{
  friend inline gpu_bool operator==(T a, const gpu_type& b);
  friend inline gpu_bool operator!=(T a, const gpu_type& b);
};

int main()
{
  gpu_int a;
  gpu_bool b = (a == 0);
}

Menyediakan operator tambahan ini sepertinya dapat menyelesaikan masalah:

template<typename T>
class gpu_type
{
  ...
  friend inline gpu_bool operator==(const gpu_type& b, T a);
  friend inline gpu_bool operator!=(const gpu_type& b, T a);
};