Mengapa kompiler C ++ tidak mendefinisikan operator == dan operator! =?

Saya penggemar berat membiarkan kompiler melakukan sebanyak mungkin pekerjaan untuk Anda. Saat menulis kelas sederhana kompiler dapat memberi Anda yang berikut ini secara 'gratis':

• Konstruktor (kosong) default
• Pembuat salinan
• Seorang destruktor
• Operator penugasan ( operator=)

Tapi sepertinya tidak bisa memberi Anda operator perbandingan - seperti operator==atau operator!=. Sebagai contoh:

class foo
{
public:
    std::string str_;
    int n_;
};

foo f1;        // Works
foo f2(f1);    // Works
foo f3;
f3 = f2;       // Works

if (f3 == f2)  // Fails
{ }

if (f3 != f2)  // Fails
{ }

Apakah ada alasan bagus untuk ini? Mengapa melakukan perbandingan anggota-oleh-anggota menjadi masalah? Tentunya jika kelas mengalokasikan memori maka Anda ingin berhati-hati, tetapi untuk kelas sederhana tentunya kompiler dapat melakukan ini untuk Anda?

Kompiler tidak akan tahu apakah Anda menginginkan perbandingan pointer atau perbandingan (internal) yang mendalam.

Lebih aman untuk tidak mengimplementasikannya dan membiarkan programmer melakukannya sendiri. Kemudian mereka dapat membuat semua asumsi yang mereka sukai.

Argumen bahwa jika kompiler dapat memberikan konstruktor salinan default, itu harus dapat memberikan default yang sama operator==()masuk akal. Saya berpikir bahwa alasan untuk keputusan untuk tidak menyediakan default yang dibuat compiler untuk operator ini dapat ditebak oleh apa yang dikatakan Stroustrup tentang konstruktor copy default di "Desain dan Evolusi C ++" (Bagian 11.4.1 - Kontrol Menyalin) :

Saya pribadi menganggap sangat disayangkan bahwa operasi penyalinan didefinisikan secara default dan saya melarang penyalinan objek dari banyak kelas saya. Namun, C ++ mewarisi penugasan default dan menyalin konstruktor dari C, dan mereka sering digunakan.

Jadi alih-alih "mengapa C ++ tidak memiliki default operator==()?", Pertanyaannya seharusnya adalah "mengapa C ++ memiliki tugas default dan menyalin konstruktor?", Dengan jawabannya adalah item-item tersebut dimasukkan dengan enggan oleh Stroustrup untuk kompatibilitas dengan C (mungkin penyebab sebagian besar kutil C ++, tetapi juga mungkin alasan utama popularitas C ++).

Untuk tujuan saya sendiri, dalam IDE saya cuplikan yang saya gunakan untuk kelas baru berisi deklarasi untuk operator penugasan pribadi dan menyalin konstruktor sehingga ketika saya membuat kelas baru saya tidak mendapatkan tugas default dan menyalin operasi - saya harus secara eksplisit menghapus deklarasi operasi-operasi tersebut dari private:bagian jika saya ingin kompiler dapat menghasilkannya untuk saya.

Bahkan di C ++ 20, kompiler masih tidak akan secara implisit menghasilkan operator==untuk Anda

struct foo
{
    std::string str;
    int n;
};

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ill-formed

Tetapi Anda akan mendapatkan kemampuan untuk secara default default == sejak C ++ 20 :

struct foo
{
    std::string str;
    int n;

    // either member form
    bool operator==(foo const&) const = default;
    // ... or friend form
    friend bool operator==(foo const&, foo const&) = default;
};

Defaulting ==dilakukan oleh anggota ==(dengan cara yang sama seperti pembuat salinan standar mengerjakan konstruksi salinan anggota). Aturan baru juga memberikan hubungan yang diharapkan antara ==dan !=. Misalnya, dengan deklarasi di atas, saya dapat menulis keduanya:

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ok!
assert(foo{"Anton", 1} != foo{"Anton", 2}); // ok!

Fitur khusus ini (default operator==dan simetri antara ==dan !=) berasal dari satu proposal yang merupakan bagian dari fitur bahasa yang lebih luas operator<=>.

IMHO, tidak ada alasan "baik". Alasan ada begitu banyak orang yang setuju dengan keputusan desain ini adalah karena mereka tidak belajar untuk menguasai kekuatan semantik berbasis nilai. Orang-orang perlu menulis banyak konstruktor salinan kustom, operator perbandingan dan destruktor karena mereka menggunakan pointer mentah dalam implementasi mereka.

Saat menggunakan smart pointer yang tepat (seperti std :: shared_ptr), konstruktor salinan default biasanya baik dan implementasi jelas dari operator perbandingan default hipotetis akan sama baiknya.

Itu dijawab C ++ tidak melakukan == karena C tidak, dan inilah mengapa C hanya menyediakan default = tetapi tidak ada == pada awalnya. C ingin tetap sederhana: C diimplementasikan = oleh memcpy; Namun, == tidak dapat diterapkan oleh memcmp karena padding. Karena padding tidak diinisialisasi, memcmp mengatakan mereka berbeda walaupun mereka sama. Masalah yang sama ada untuk kelas kosong: memcmp mengatakan mereka berbeda karena ukuran kelas kosong bukan nol. Dapat dilihat dari atas bahwa implementasi == lebih rumit daripada implementasi = dalam C. Beberapa contoh kode mengenai ini. Koreksi Anda dihargai jika saya salah.

Dalam video ini Alex Stepanov, pencipta STL menjawab pertanyaan ini sekitar pukul 13:00. Sebagai rangkuman, setelah menyaksikan evolusi C ++ ia berpendapat bahwa:

• Sangat disayangkan bahwa == dan! = Tidak dinyatakan secara implisit (dan Bjarne setuju dengannya). Bahasa yang benar seharusnya sudah siap untuk Anda (dia melangkah lebih jauh untuk menyarankan Anda seharusnya tidak dapat mendefinisikan ! = Yang memecah semantik dari == )
• Alasannya adalah kasus ini berakar (karena banyak masalah C ++) di C. Di sana, operator penugasan secara implisit didefinisikan dengan penugasan sedikit demi sedikit tetapi itu tidak akan berhasil untuk == . Penjelasan lebih rinci dapat ditemukan dalam artikel ini dari Bjarne Stroustrup.
• Dalam pertanyaan tindak lanjut Mengapa kemudian bukan perbandingan anggota dengan anggota digunakan, dia mengatakan hal yang luar biasa : C adalah jenis bahasa yang di-homegrown dan orang yang mengimplementasikan hal-hal ini untuk Ritchie mengatakan kepadanya bahwa dia merasa ini sulit untuk diimplementasikan!

Dia kemudian mengatakan bahwa di masa depan (jauh) == dan ! = Akan dihasilkan secara implisit.

C ++ 20 menyediakan cara untuk dengan mudah mengimplementasikan operator perbandingan default.

Contoh dari cppreference.com :

class Point {
    int x;
    int y;
public:
    auto operator<=>(const Point&) const = default;
    // ... non-comparison functions ...
};

// compiler implicitly declares operator== and all four relational operators work
Point pt1, pt2;
if (pt1 == pt2) { /*...*/ } // ok, calls implicit Point::operator==
std::set<Point> s; // ok
s.insert(pt1); // ok
if (pt1 <= pt2) { /*...*/ } // ok, makes only a single call to Point::operator<=>

Tidak mungkin untuk mendefinisikan default ==, tetapi Anda dapat menentukan default !=melalui ==mana Anda biasanya harus mendefinisikan sendiri. Untuk ini, Anda harus melakukan hal-hal berikut:

#include <utility>
using namespace std::rel_ops;
...

class FooClass
{
public:
  bool operator== (const FooClass& other) const {
  // ...
  }
};

Anda dapat melihat http://www.cplusplus.com/reference/std/utility/rel_ops/ untuk detailnya.

Selain itu jika Anda mendefinisikan operator< , operator untuk <=,>,> = dapat disimpulkan dari itu ketika menggunakan std::rel_ops.

Tetapi Anda harus berhati-hati ketika menggunakan std::rel_opskarena operator pembanding dapat disimpulkan untuk jenis yang tidak Anda harapkan.

Cara yang lebih disukai untuk menyimpulkan operator terkait dari yang dasar adalah menggunakan boost :: operator .

Pendekatan yang digunakan dalam boost lebih baik karena mendefinisikan penggunaan operator untuk kelas yang Anda inginkan, bukan untuk semua kelas dalam ruang lingkup.

Anda juga dapat menghasilkan "+" dari "+ =", - dari "- =", dll ... (lihat daftar lengkap di sini )

C ++ 0x telah memiliki proposal untuk fungsi-fungsi default, sehingga Anda dapat mengatakan default operator==; Kami telah belajar bahwa ini membantu untuk membuat hal-hal ini eksplisit.

Secara konseptual tidak mudah untuk mendefinisikan kesetaraan. Bahkan untuk data POD, orang dapat berargumen bahwa bahkan jika bidangnya sama, tetapi itu adalah objek yang berbeda (pada alamat yang berbeda) tidak harus sama. Ini sebenarnya tergantung pada penggunaan operator. Sayangnya kompiler Anda tidak bersifat psikis dan tidak dapat menyimpulkannya.

Selain itu, fungsi default adalah cara terbaik untuk menembak diri sendiri di kaki. Default yang Anda jelaskan pada dasarnya ada untuk menjaga kompatibilitas dengan POD struct. Namun mereka menyebabkan lebih dari cukup kekacauan dengan pengembang lupa tentang mereka, atau semantik dari implementasi standar.

Apakah ada alasan bagus untuk ini? Mengapa melakukan perbandingan anggota-oleh-anggota menjadi masalah?

Ini mungkin bukan masalah secara fungsional, tetapi dalam hal kinerja, perbandingan anggota-per-anggota standar cenderung lebih sub-optimal daripada penugasan / penyalinan anggota-oleh-anggota standar. Tidak seperti urutan penugasan, urutan perbandingan berdampak pada kinerja karena anggota yang tidak setara pertama menyiratkan yang lainnya dapat dilewati. Jadi, jika ada beberapa anggota yang biasanya sama, Anda ingin membandingkannya terakhir, dan kompilator tidak tahu anggota mana yang lebih mungkin sama.

Pertimbangkan contoh ini, di mana verboseDescriptionstring panjang dipilih dari serangkaian deskripsi cuaca yang relatif kecil.

class LocalWeatherRecord {
    std::string verboseDescription;
    std::tm date;
    bool operator==(const LocalWeatherRecord& other){
        return date==other.date
            && verboseDescription==other.verboseDescription;
    // The above makes a lot more sense than
     // return verboseDescription==other.verboseDescription
     //     && date==other.date;
    // because some verboseDescriptions are liable to be same/similar
    }
}

(Tentu saja kompiler akan berhak mengabaikan urutan perbandingan jika mengakui bahwa mereka tidak memiliki efek samping, tetapi mungkin masih akan mengambil que dari kode sumber di mana ia tidak memiliki informasi yang lebih baik sendiri.)

Hanya agar jawaban atas pertanyaan ini tetap lengkap seiring berjalannya waktu: karena C ++ 20 dapat secara otomatis dihasilkan dengan perintah auto operator<=>(const foo&) const = default;

Ini akan menghasilkan semua operator: ==,! =, <, <=,>, Dan> =, lihat https://en.cppreference.com/w/cpp/language/default_comparisons untuk detailnya.

Karena tampilan operator <=>, itu disebut operator pesawat ruang angkasa. Lihat juga Mengapa kita membutuhkan operator pesawat ruang angkasa <=> di C ++? .

EDIT: juga di C ++ 11 pengganti yang cukup rapi untuk yang tersedia dengan std::tiemelihat https://en.cppreference.com/w/cpp/utility/tuple/tie untuk contoh kode lengkap dengan bool operator<(…). Bagian yang menarik, diubah untuk bekerja dengan ==adalah:

#include <tuple>

struct S {
………
bool operator==(const S& rhs) const
    {
        // compares n to rhs.n,
        // then s to rhs.s,
        // then d to rhs.d
        return std::tie(n, s, d) == std::tie(rhs.n, rhs.s, rhs.d);
    }
};

std::tie bekerja dengan semua operator perbandingan, dan sepenuhnya dioptimalkan oleh kompiler.

Saya setuju, untuk kelas tipe POD maka kompiler dapat melakukannya untuk Anda. Namun apa yang Anda anggap sederhana kompiler mungkin salah. Jadi lebih baik membiarkan programmer melakukannya.

Saya pernah memiliki kasus POD di mana dua bidang unik - sehingga perbandingan tidak akan pernah dianggap benar. Namun perbandingan yang saya butuhkan hanya pernah dibandingkan pada payload - sesuatu yang kompiler tidak akan pernah mengerti atau pernah bisa mengetahuinya sendiri.

Selain itu - mereka tidak butuh waktu lama untuk menulis, kan ?!