Apa yang dimaksud dengan operator <=> di C ++?

Ketika saya mencoba mempelajari tentang operator C ++ , saya menemukan sebuah operator perbandingan aneh di cppreference.com , ^* dalam tabel yang terlihat seperti ini:

"Yah, jika ini adalah operator umum di C ++, saya lebih baik mempelajarinya", pikir saya. Tetapi semua upaya saya untuk menjelaskan misteri ini tidak berhasil. Bahkan di sini, di Stack Overflow, saya tidak beruntung dalam pencarian saya.

Apakah ada koneksi antara <=> dan C ++ ?

Dan jika ada, apa tepatnya yang dilakukan operator ini?

_{* Sementara itu cppreference.com memperbarui halaman itu dan sekarang berisi informasi tentang <=>operator.}

Ini disebut operator perbandingan tiga arah .

Menurut proposal makalah P0515 :

Ada operator perbandingan tiga arah baru <=>,. Ekspresi a <=> bmengembalikan objek yang membandingkan <0jika a < b, membandingkan >0jika a > b, dan membandingkan ==0jika adan bsama / setara.

Untuk menulis semua perbandingan untuk jenis Anda, tulis saja operator<=>yang mengembalikan jenis kategori yang sesuai:

• Kembali sebuah _ordering jika jenis Anda secara alami mendukung <, dan kami akan efisien menghasilkan <, >, <=, >=, ==, dan !=; jika tidak, kembalikan _equality , dan kami akan menghasilkan == dan ! = secara efisien .

• Kembalilah kuat jika untuk tipe Anda a == bmenyiratkan f(a) == f(b)(dapat disubstitusikan, di mana f hanya membaca keadaan yang menonjol perbandingan dapat diakses menggunakan antarmuka const nonprivate), jika tidak kembalikan lemah.

The cppreference mengatakan:

Ekspresi operator perbandingan tiga arah memiliki formulir

lhs <=> rhs   (1)  

Ekspresi mengembalikan objek itu

• membandingkan <0jikalhs < rhs
• membandingkan >0jikalhs > rhs
• dan membandingkan ==0jika lhsdan rhssama / setara.

Pada 2017-11-11 , komite ISO C ++ mengadopsi proposal Herb Sutter untuk operator perbandingan tiga arah <=> "pesawat ruang angkasa" sebagai salah satu fitur baru yang ditambahkan ke C ++ 20 . Dalam makalah berjudul Sutter perbandingan Konsisten , Maurer dan Brown mendemonstrasikan konsep-konsep desain baru. Untuk ikhtisar proposal, berikut adalah kutipan dari artikel:

Ekspresi a <=> b mengembalikan objek yang membandingkan <0 jika a <b , membandingkan > 0 jika a> b , dan membandingkan == 0 jika a dan b sama / setara.

Kasus umum: Untuk menulis semua perbandingan untuk tipe X Anda dengan tipe Y , dengan semantik anggota, cukup tulis:

auto X::operator<=>(const Y&) =default;

Kasus tingkat lanjut: Untuk menulis semua perbandingan untuk tipe X Anda dengan tipe Y , cukup tulis operator <=> yang menggunakan Y , dapat menggunakan = default untuk mendapatkan semantik yang sesuai dengan anggota jika diinginkan, dan mengembalikan jenis kategori yang sesuai:

• Kembalikan _ordering jika jenis Anda secara alami mendukung < , dan kami akan secara efisien menghasilkan simetris < , > , <= , > = , == , dan ! = ; jika tidak mengembalikan _equality , dan kami akan menghasilkan symmetric == dan ! = secara efisien .
• Kembalikan strong_ jika untuk tipe Anda a == b menyiratkan f (a) == f (b) (dapat disubstitusikan, di mana f hanya membaca keadaan yang menonjol perbandingan yang dapat diakses menggunakan anggota const publik ), jika tidak kembalikan lemah_ .

Kategori Perbandingan

Lima kategori perbandingan didefinisikan sebagai std::tipe, masing-masing memiliki nilai yang telah ditentukan sebelumnya:

+--------------------------------------------------------------------+
|                  |          Numeric  values          | Non-numeric |
|     Category     +-----------------------------------+             |
|                  | -1   | 0          | +1            |   values    |
+------------------+------+------------+---------------+-------------+
| strong_ordering  | less | equal      | greater       |             |
| weak_ordering    | less | equivalent | greater       |             |
| partial_ordering | less | equivalent | greater       | unordered   |
| strong_equality  |      | equal      | nonequal      |             |
| weak_equality    |      | equivalent | nonequivalent |             |
+------------------+------+------------+---------------+-------------+

Konversi tersirat di antara jenis-jenis ini didefinisikan sebagai berikut:

• strong_orderingdengan nilai-nilai { less, equal, greater} implisit mengkonversi ke:
  • weak_orderingdengan nilai-nilai { less, equivalent, greater}
  • partial_orderingdengan nilai-nilai { less, equivalent, greater}
  • strong_equalitydengan nilai-nilai { unequal, equal, unequal}
  • weak_equalitydengan nilai-nilai { nonequivalent, equivalent, nonequivalent}
• weak_orderingdengan nilai-nilai { less, equivalent, greater} implisit mengkonversi ke:
  • partial_orderingdengan nilai-nilai { less, equivalent, greater}
  • weak_equalitydengan nilai-nilai { nonequivalent, equivalent, nonequivalent}
• partial_orderingdengan nilai-nilai { less, equivalent, greater, unordered} implisit mengkonversi ke:
  • weak_equalitydengan nilai-nilai { nonequivalent, equivalent, nonequivalent, nonequivalent}
• strong_equalitydengan nilai { equal, unequal} secara implisit dikonversi ke:
  • weak_equalitydengan nilai { equivalent, nonequivalent}

Perbandingan tiga arah

The <=>token diperkenalkan. Urutan karakter <=>menjadi tokenizes <= >, dalam kode sumber lama. Misalnya, X<&Y::operator<=>perlu menambahkan ruang untuk mempertahankan maknanya.

Operator kelebihan beban <=>adalah fungsi perbandingan tiga arah dan memiliki prioritas lebih tinggi dari <dan lebih rendah dari <<. Ini mengembalikan jenis yang dapat dibandingkan dengan literal 0tetapi jenis kembali lainnya diizinkan seperti untuk mendukung templat ekspresi. Semua <=>operator yang didefinisikan dalam bahasa dan di perpustakaan standar mengembalikan salah satu dari 5 std::jenis kategori perbandingan yang disebutkan di atas .

Untuk jenis bahasa, <=>perbandingan built-in dengan jenis yang sama disediakan. Semua adalah constexpr , kecuali jika disebutkan sebaliknya. Perbandingan ini tidak dapat dilakukan secara heterogen menggunakan promosi / konversi skalar.

• Untuk bool, integral, dan tipe penunjuk, <=>pengembalian strong_ordering.
• Untuk tipe penunjuk, berbagai kualifikasi-cv dan konversi turunan ke basis diizinkan untuk memanggil built-in yang homogen <=>, dan ada built-in yang heterogen operator<=>(T*, nullptr_t). Hanya perbandingan pointer ke objek / alokasi yang sama yang merupakan ekspresi konstan.
• Untuk tipe floating point yang mendasar, <=>pengembalian partial_ordering, dan dapat dipanggil secara heterogen dengan memperluas argumen ke tipe floating point yang lebih besar.
• Untuk enumerasi, <=>kembalikan sama dengan tipe dasar enumerasi <=>.
• Untuk nullptr_t, <=>pengembalian , strong_orderingdan selalu hasil equal.
• Untuk array menyatakan bahwa pihak, T[N] <=> T[N]mengembalikan jenis yang sama seperti T's <=>dan Melakukan perbandingan elementwise leksikografis. Tidak ada <=>untuk array lainnya.
• Karena voidtidak ada <=>.

_{Untuk lebih memahami cara kerja bagian dalam operator ini, silakan baca makalah aslinya . Ini adalah apa yang saya temukan menggunakan mesin pencari.}

Jawaban ini menjadi tidak relevan karena halaman web yang dirujuk telah berubah

The web page Anda referensi rusak. Itu sedang banyak diedit hari itu dan bagian yang berbeda tidak sinkron. Status ketika saya melihatnya adalah:

Di bagian atas halaman ini daftar operator perbandingan yang ada saat ini (dalam C ++ 14). Tidak ada <=>disana.

Di bagian bawah halaman, mereka seharusnya mendaftar operator yang sama, tetapi mereka melakukan kesalahan dan menambahkan saran ini di masa depan.

gccbelum tahu tentang <=>(dan dengan -std=c++14, tidak akan pernah), jadi menurut Anda maksud Anda a <= > b. Ini menjelaskan pesan kesalahan.

Jika Anda mencoba hal yang sama lima tahun dari sekarang, Anda mungkin akan mendapatkan pesan kesalahan yang lebih baik, seperti <=> not part of C++14.