Mengapa std :: set tidak memiliki fungsi anggota "berisi"?

Saya banyak menggunakan std::set<int>dan seringkali saya hanya perlu memeriksa apakah set seperti itu berisi angka atau tidak.

Menurut saya wajar untuk menulis:

if (myset.contains(number))
   ...

Tetapi karena kekurangan containsanggota, saya perlu menulis yang rumit:

if (myset.find(number) != myset.end())
  ..

atau yang tidak begitu jelas:

if (myset.count(element) > 0) 
  ..

Apakah ada alasan untuk keputusan desain ini?

Saya rasa itu mungkin karena mereka berusaha membuat std::setdan std::multisetsemirip mungkin. (Dan jelas countmemiliki arti yang sangat masuk akal untuk std::multiset.)

Secara pribadi saya pikir ini adalah kesalahan.

Tidak terlalu buruk jika Anda berpura-pura bahwa countitu hanya salah eja containsdan menulis tes sebagai:

if (myset.count(element)) 
   ...

Itu masih memalukan.

Untuk dapat menulis if (s.contains()), contains()harus mengembalikan bool(atau tipe yang dapat dikonversi bool, yang merupakan cerita lain), seperti binary_searchhalnya.

The alasan mendasar di balik keputusan desain tidak untuk melakukannya dengan cara ini adalah bahwa contains()yang mengembalikan boolakan kehilangan informasi berharga tentang di mana unsur ini dalam koleksi . find()mempertahankan dan mengembalikan informasi tersebut dalam bentuk iterator, oleh karena itu merupakan pilihan yang lebih baik untuk pustaka generik seperti STL. Ini selalu menjadi prinsip panduan Alex Stepanov, seperti yang sering dia jelaskan (misalnya, di sini ).

Mengenai count()pendekatan secara umum, meskipun sering kali merupakan solusi yang baik, masalah dengan itu adalah bahwa ia melakukan lebih banyak pekerjaan daripada yang contains() harus dilakukan .

Itu tidak berarti bahwa a bool contains()bukanlah sesuatu yang sangat bagus untuk dimiliki atau bahkan diperlukan. Beberapa waktu yang lalu kami berdiskusi panjang tentang masalah yang sama ini di grup ISO C ++ Standard - Future Proposals.

Itu kurang karena tidak ada yang menambahkannya. Tidak ada yang menambahkannya karena kontainer dari STL yang stddimasukkan perpustakaan dirancang untuk menjadi antarmuka yang minimal. (Perhatikan bahwa std::stringtidak berasal dari STL dengan cara yang sama).

Jika Anda tidak keberatan dengan sintaks yang aneh, Anda dapat memalsukannya:

template<class K>
struct contains_t {
  K&& k;
  template<class C>
  friend bool operator->*( C&& c, contains_t&& ) {
    auto range = std::forward<C>(c).equal_range(std::forward<K>(k));
    return range.first != range.second;
    // faster than:
    // return std::forward<C>(c).count( std::forward<K>(k) ) != 0;
    // for multi-meows with lots of duplicates
  }
};
template<class K>
containts_t<K> contains( K&& k ) {
  return {std::forward<K>(k)};
}

menggunakan:

if (some_set->*contains(some_element)) {
}

Pada dasarnya, Anda dapat menulis metode ekstensi untuk sebagian besar stdjenis C ++ menggunakan teknik ini.

Jauh lebih masuk akal untuk hanya melakukan ini:

if (some_set.count(some_element)) {
}

tapi saya terhibur dengan metode metode ekstensi.

Hal yang sangat menyedihkan adalah bahwa menulis efisien containsbisa lebih cepat pada multimapatau multiset, karena mereka hanya perlu menemukan satu elemen, sementara countharus menemukan masing-masing dan menghitungnya .

Sebuah multiset yang berisi 1 miliar salinan 7 (Anda tahu, seandainya kehabisan) bisa sangat lambat .count(7), tetapi bisa sangat cepat contains(7).

Dengan metode ekstensi di atas, kita dapat mempercepat kasus ini dengan menggunakan lower_bound, membandingkan end, dan kemudian membandingkan dengan elemen. Namun, melakukan itu untuk meong yang tidak berurutan serta meong yang dipesan akan membutuhkan SFINAE yang mewah atau kelebihan muatan khusus kontainer.

Anda mencari kasus tertentu dan tidak melihat gambaran yang lebih besar. Sebagaimana dinyatakan dalam dokumentasi, std::set memenuhi persyaratan konsep AssociativeContainer . Untuk konsep itu tidak masuk akal untuk memiliki containsmetode, karena tidak banyak berguna untuk std::multisetdan std::multimap, tetapi countberfungsi dengan baik untuk semuanya. Meskipun metode containsdapat ditambahkan sebagai alias untuk countuntuk std::set, std::mapdan versi hash mereka (seperti lengthuntuk size()di std::string), tapi terlihat seperti pencipta perpustakaan tidak melihat kebutuhan nyata untuk itu.

Meskipun saya tidak tahu mengapa std::settidak ada containstetapi countyang hanya pernah kembali 0atau 1, Anda dapat menulis containsfungsi pembantu template seperti ini:

template<class Container, class T>
auto contains(const Container& v, const T& x)
-> decltype(v.find(x) != v.end())
{
    return v.find(x) != v.end();
}

Dan gunakan seperti ini:

    if (contains(myset, element)) ...

Alasan sebenarnya setadalah misteri bagi saya, tetapi satu kemungkinan penjelasan untuk desain yang sama ini mapadalah untuk mencegah orang menulis kode yang tidak efisien secara tidak sengaja:

if (myMap.contains("Meaning of universe"))
{
    myMap["Meaning of universe"] = 42;
}

Yang akan menghasilkan dua mappencarian.

Sebaliknya, Anda dipaksa untuk mendapatkan iterator. Ini memberi Anda petunjuk mental bahwa Anda harus menggunakan kembali iterator:

auto position = myMap.find("Meaning of universe");
if (position != myMap.cend())
{
    position->second = 42;
}

yang hanya menggunakan satu mappencarian.

Ketika kita menyadarinya setdan mapdibuat dari daging yang sama, kita dapat menerapkan prinsip ini juga pada set. Artinya, jika kita ingin bertindak atas item di sethanya jika ada di set, desain ini dapat mencegah kita menulis kode seperti ini:

struct Dog
{
    std::string name;
    void bark();
}

operator <(Dog left, Dog right)
{
    return left.name < right.name;
}

std::set<Dog> dogs;
...
if (dogs.contain("Husky"))
{
    dogs.find("Husky")->bark();
}

Tentu semua ini hanyalah spekulasi belaka.

Sejak c ++ 20,

bool contains( const Key& key ) const

tersedia.

Bagaimana dengan binary_search?

 set <int> set1;
 set1.insert(10);
 set1.insert(40);
 set1.insert(30);
 if(std::binary_search(set1.begin(),set1.end(),30))
     bool found=true;

berisi () harus mengembalikan bool. Menggunakan kompiler C ++ 20 saya mendapatkan output berikut untuk kode:

#include<iostream>
#include<map>
using namespace std;

int main()
{
    multimap<char,int>mulmap;
    mulmap.insert(make_pair('a', 1)); //multiple similar key
    mulmap.insert(make_pair('a', 2)); //multiple similar key
    mulmap.insert(make_pair('a', 3)); //multiple similar key
    mulmap.insert(make_pair('b', 3));
    mulmap.insert({'a',4});
    mulmap.insert(pair<char,int>('a', 4));
    
    cout<<mulmap.contains('c')<<endl;  //Output:0 as it doesn't exist
    cout<<mulmap.contains('b')<<endl;  //Output:1 as it exist
}

Alasan lain adalah bahwa hal itu akan memberikan kesan yang salah kepada programmer bahwa std :: set adalah himpunan dalam pengertian teori himpunan matematika. Jika mereka mengimplementasikannya, maka banyak pertanyaan lain akan mengikuti: jika sebuah std :: set memiliki berisi () untuk sebuah nilai, mengapa ia tidak memilikinya untuk set lain? Di mana union (), intersection () dan operasi dan predikat himpunan lainnya?

Jawabannya adalah, tentu saja, beberapa operasi himpunan sudah diimplementasikan sebagai fungsi di (std :: set_union () dll.) Dan lainnya diimplementasikan semudah berisi (). Fungsi dan objek fungsi bekerja lebih baik dengan abstraksi matematika daripada anggota objek, dan mereka tidak terbatas pada jenis wadah tertentu.

Jika seseorang perlu mengimplementasikan fungsionalitas set-matematika lengkap, dia tidak hanya memiliki pilihan wadah yang mendasarinya, tetapi juga dia memiliki pilihan detail implementasi, misalnya, apakah fungsi theory_union () -nya akan berfungsi dengan objek yang tidak dapat diubah, lebih cocok untuk pemrograman fungsional , atau apakah itu akan memodifikasi operannya dan menghemat memori? Apakah ini akan diimplementasikan sebagai objek fungsi dari awal atau akan lebih baik jika diimplementasikan adalah fungsi-C, dan gunakan std :: function <> jika diperlukan?

Seperti sekarang, std :: set hanyalah sebuah wadah, cocok untuk implementasi himpunan dalam pengertian matematika, tetapi ini hampir jauh dari himpunan teoretis seperti std :: vector dari vektor teoretis.