Mengapa ketidaksetaraan diuji sebagai (! (A == b)) di banyak kode pustaka standar C ++?

Ini adalah kode dari removekode pustaka standar C ++ . Mengapa ketimpangan diuji sebagai if (!(*first == val))ganti if (*first != val)?

 template <class ForwardIterator, class T>
      ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
 {
     ForwardIterator result = first;
     while (first!=last) {
         if (!(*first == val)) {
             *result = *first;
             ++result;
         }
         ++first;
     }
     return result;
 }

Karena ini berarti satu-satunya persyaratan pada T adalah untuk mengimplementasikan operator==. Anda dapat meminta T untuk memiliki operator!=tetapi gagasan umum di sini adalah bahwa Anda harus memberi beban sesedikit mungkin kepada pengguna template dan template lain memang perlu operator==.

Sebagian besar fungsi dalam STL hanya bekerja dengan operator<atau operator==. Ini mengharuskan pengguna hanya untuk mengimplementasikan dua operator ini (atau kadang-kadang setidaknya satu dari mereka). Misalnya std::setmenggunakan operator<(lebih tepatnya std::lessyang memanggil operator<secara default) dan tidak operator>mengelola pemesanan. The removetemplate contoh Anda adalah kasus serupa - hanya menggunakan operator==dan tidak operator!=sehingga operator!=tidak perlu didefinisikan.

Ini adalah kode dari pustaka penghapusan kode standar C ++.

Salah. Ini bukan yang C ++ library standar removekode. Ini adalah salah satu implementasi internal dari removefungsi pustaka standar C ++ . Standar C ++ tidak menentukan kode aktual; itu menetapkan prototipe fungsi dan perilaku yang diperlukan.

Dengan kata lain: Dari sudut pandang bahasa yang ketat, kode yang Anda lihat tidak ada . Mungkin dari beberapa file header yang datang dengan implementasi perpustakaan standar compiler Anda. Perhatikan bahwa standar C ++ bahkan tidak mengharuskan file header itu ada. File hanyalah cara yang nyaman bagi implementator kompiler untuk memenuhi persyaratan untuk jalur seperti #include <algorithm>(yaitu membuat std::removedan fungsi lainnya tersedia).

Mengapa ketimpangan diuji sebagai if (!(*first == val))ganti if (*first != val)?

Karena hanya operator==diperlukan oleh fungsi.

Ketika berbicara tentang overloading operator untuk tipe khusus, bahasa ini memungkinkan Anda melakukan semua jenis hal aneh. Anda bisa membuat kelas yang memiliki kelebihan operator==tetapi tidak kelebihan operator!=. Atau bahkan lebih buruk: Anda bisa kelebihan beban operator!=tetapi membuatnya melakukan hal-hal yang sama sekali tidak terkait.

Pertimbangkan contoh ini:

#include <algorithm>
#include <vector>

struct Example
{
    int i;

    Example() : i(0) {}

    bool operator==(Example const& other) const
    {
        return i == other.i;
    }

    bool operator!=(Example const& other) const
    {
        return i == 5; // weird, but nothing stops you
                       // from doing so
    }

};

int main()
{
  std::vector<Example> v(10);
  // ...
  auto it = std::remove(v.begin(), v.end(), Example());
  // ...
}

Jika std::removedigunakan operator!=, maka hasilnya akan sangat berbeda.

Beberapa jawaban bagus di sini. Saya hanya ingin menambahkan sedikit catatan.

Seperti semua perpustakaan yang baik, perpustakaan standar dirancang dengan (setidaknya) dua prinsip yang sangat penting dalam pikiran:

1. Berikan paling sedikit tanggung jawab pada pengguna perpustakaan Anda yang bisa Anda hindari. Sebagian dari ini berkaitan dengan memberi mereka jumlah pekerjaan paling sedikit untuk dilakukan saat menggunakan antarmuka Anda. (Seperti mendefinisikan beberapa operator karena Anda bisa lolos). Bagian lain dari itu ada hubungannya dengan tidak mengejutkan mereka atau mengharuskan mereka untuk memeriksa kode kesalahan (jadi menjaga antarmuka konsisten dan membuang pengecualian dari <stdexcept>saat ada masalah).

2. Hilangkan semua redundansi logis . Semua perbandingan dapat disimpulkan hanya dari operator<, jadi mengapa menuntut pengguna untuk mendefinisikan yang lain? misalnya:

   (a> b) setara dengan (b <a)

   (a> = b) setara dengan! (a <b)

   (a == b) setara dengan! ((a <b) || (b <a))

   dan seterusnya.

   Tentu saja pada catatan ini, orang mungkin bertanya mengapa unordered_mapmemerlukan operator==(setidaknya secara default) daripada operator<. Jawabannya adalah bahwa dalam tabel hash satu-satunya perbandingan yang pernah kita butuhkan adalah satu untuk kesetaraan. Dengan demikian lebih konsisten secara logis (yaitu lebih masuk akal bagi pengguna perpustakaan) untuk meminta mereka mendefinisikan operator kesetaraan. Membutuhkan operator<akan membingungkan karena tidak segera jelas mengapa Anda membutuhkannya.

The EqualityComparableKonsep hanya mengharuskan operator==didefinisikan.

Akibatnya, fungsi apa pun yang mengaku bekerja dengan jenis yang memuaskan EqualityComparable tidak bisa bergantung pada keberadaan operator!=objek untuk jenis itu. (kecuali ada persyaratan tambahan yang menyiratkan adanya operator!=).

Pendekatan yang paling menjanjikan adalah menemukan metode untuk menentukan apakah operator == dapat dipanggil untuk jenis tertentu, dan kemudian mendukungnya hanya jika tersedia; dalam situasi lain, pengecualian akan dilempar. Namun, hingga saat ini tidak ada cara yang diketahui untuk mendeteksi apakah ekspresi operator yang sewenang-wenang f ==g didefinisikan dengan tepat. Solusi terbaik yang dikenal memiliki kualitas yang tidak diinginkan berikut:

• Gagal pada waktu kompilasi untuk objek di mana operator == tidak dapat diakses (misalnya, karena bersifat pribadi).
• Gagal pada waktu kompilasi jika memanggil operator == ambigu.
• Tampaknya benar jika operator == pernyataan sudah benar, meskipun operator == mungkin tidak dapat dikompilasi.

Dari Boost FAQ: sumber

Mengetahui bahwa membutuhkan ==implementasi adalah beban , Anda tidak pernah ingin membuat beban tambahan dengan meminta !=implementasi juga.

Bagi saya pribadi ini tentang bagian S SOLID (desain berorientasi objek) - Prinsip substitusi Liskov: "objek dalam program harus dapat diganti dengan instance subtipe mereka tanpa mengubah kebenaran program itu.". Dalam hal ini adalah operator ! = Yang dapat saya ganti dengan == dan boolean inverse dalam logika boolean.