Std :: set neden "içerir" üye işlevine sahip değil?

Yoğun bir şekilde kullanıyorum std::set<int>ve çoğu zaman böyle bir setin bir sayı içerip içermediğini kontrol etmem gerekiyor.

Yazmayı doğal buluyorum:

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

Ancak bir containsüye olmadığı için hantal yazmam gerekiyor:

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

veya o kadar bariz değil:

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

Bu tasarım kararının bir nedeni var mı?

Sanırım bu muhtemelen yapmaya çalıştıkları std::setve std::multisetolabildiğince benzer oldukları içindir . (Ve açıkça countbunun için son derece mantıklı bir anlamı var std::multiset.)

Şahsen bunun bir hata olduğunu düşünüyorum.

Bunun countsadece bir yazım hatası olduğunu düşünürseniz containsve testi şöyle yazarsanız, o kadar da kötü görünmez :

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

Yine de utanç verici.

Yazabilmek için if (s.contains()), contains()yaptığı gibi bir bool(veya boolbaşka bir hikaye olan dönüştürülebilir bir tür) döndürmek zorundadır binary_search.

Temel nedeni tasarım kararın arkasında değil bu şekilde bunu yapmak için yani contains()bir döndüren boolediyorum eleman koleksiyonunda olduğu hakkında değerli bilgiler kaybetmek . find()bu bilgiyi bir yineleyici biçiminde korur ve döndürür, bu nedenle STL gibi genel bir kitaplık için daha iyi bir seçimdir. Bu, Alex Stepanov için her zaman yol gösterici ilke olmuştur, sık sık açıkladığı gibi (örneğin, burada ).

Genel olarak count()yaklaşıma gelince , çoğu zaman sorun olmayan bir çözüm olsa da, bununla ilgili sorun, a'nın yapması gerekenden daha fazla iş contains() yapmasıdır .

Bu, a'nın sahip bool contains()olması çok hoş ve hatta gerekli olmadığı anlamına gelmez. Bir süre önce, aynı konu hakkında ISO C ++ Standardı - Gelecek Öneriler grubunda uzun bir tartışma yaptık .

Eksik çünkü kimse eklemedi. Kimse eklemedi çünkü STL'deki kaplar, stdarayüzde minimum olacak şekilde tasarlandığı yere dahil edildi. ( std::stringAynı şekilde STL'den gelmediğini unutmayın ).

Garip bir sözdizimine aldırmazsanız, taklit edebilirsiniz:

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)};
}

kullanım:

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

Temel olarak, stdbu tekniği kullanarak çoğu C ++ türü için uzatma yöntemleri yazabilirsiniz .

Bunu yapmak çok daha mantıklı:

if (some_set.count(some_element)) {
}

ama uzatma metodu ile eğleniyorum.

Gerçekten üzücü olan şey, verimli yazmak contains, bir multimapveya üzerinde daha hızlı olabilir multiset, çünkü sadece bir öğeyi bulmaları gerekirken count, her birini bulup saymaları gerekir .

7'nin 1 milyar kopyasını içeren bir çoklu kümenin (bilirsiniz, bitmesi durumunda) gerçekten yavaş .count(7)olabilir, ancak çok hızlı olabilir contains(7).

Yukarıdaki genişletme yöntemiyle, öğeyi kullanarak lower_bound, karşılaştırarak endve sonra onu karşılaştırarak bu durum için daha hızlı hale getirebiliriz . Sırasız bir miyav için olduğu kadar düzenli bir miyav için bunu yapmak, süslü SFINAE veya konteynere özgü aşırı yüklemeler gerektirecektir.

Belirli bir vakaya bakıyorsunuz ve büyük resmi görmüyorsunuz. Belgelerde belirtildiği gibi AssociativeContainer konseptinin std::setgereksinimlerini karşılar . Bu kavram için ona sahip olmak bir anlam ifade etmez onun için hemen hemen hiçbir işe yaramaz olarak, yöntem ve fakat hepsi için para cezası çalışır. Yöntem olsa bir için takma ad olarak eklenebilir için , ve bunların karma sürümleri (gibi için de ), ancak kütüphane yaratıcıları gibi görünüyor bunun için gerçek gerek görmedi.containsstd::multisetstd::multimapcountcontainscountstd::setstd::maplengthsize()std::string

Neden bilmiyorum rağmen std::sethiçbir vardır containsama counthangi sadece hiç döner 0ya 1, bir templated yazabilirsiniz containsböyle yardımcı işlevi:

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();
}

Ve bunu şu şekilde kullanın:

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

Bunun gerçek nedeni benim için setbir gizem, ancak aynı tasarımın olası bir açıklaması, mapinsanların kazara verimsiz kod yazmasını engellemek olabilir:

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

Bu, iki maparamayla sonuçlanır .

Bunun yerine, bir yineleyici almaya zorlanırsınız. Bu size yineleyiciyi yeniden kullanmanız gerektiğine dair zihinsel bir ipucu verir:

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

yalnızca bir maparama tüketir .

Bunu anladığımızda setve mapaynı etten yapıldığımızda, bu prensibi için de uygulayabiliriz set. Yani, bir öğe üzerinde hareket etmek istiyorsak, setyalnızca içinde mevcutsa set, bu tasarım şu şekilde kod yazmamızı engelleyebilir:

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();
}

Elbette tüm bunlar sadece bir spekülasyon.

C ++ 20'den beri,

bool contains( const Key& key ) const

gecerli.

Binary_search ne olacak?

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

contains () bir bool döndürmelidir. C ++ 20 derleyicisini kullanarak kod için aşağıdaki çıktıyı alıyorum:

#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
}

Diğer bir neden, programcıya std :: set'in matematik küme teorisi anlamında bir küme olduğu yanlış izlenimi vermesidir. Eğer bunu uygularlarsa, pek çok soru da gelir: eğer bir std :: set bir değer için () içeriyorsa, neden başka bir set için ona sahip değil? Union (), kesişim () ve diğer küme işlemleri ve yüklemler nerede?

Cevap, elbette, küme işlemlerinden bazılarının (std :: set_union () vb.) İşlevler olarak zaten uygulandığı ve diğerlerinin de contains () kadar önemsiz bir şekilde uygulandığıdır. İşlevler ve işlev nesneleri, matematik soyutlamalarıyla nesne üyelerine göre daha iyi çalışır ve belirli bir kap türüyle sınırlı değildirler.

Tam bir matematiksel küme işlevselliği uygulamaya ihtiyaç duyulursa, yalnızca temel kapsayıcı seçimi yapmakla kalmaz, aynı zamanda uygulama ayrıntıları seçimi de vardır, örneğin, teori_union () işlevi, işlevsel programlama için daha uygun olan değişmez nesnelerle çalışır mı? veya işlenenlerini değiştirip hafızadan tasarruf eder miydi? Başlangıçtan itibaren işlev nesnesi olarak mı uygulanacak, yoksa C işlevinin uygulanması ve gerekirse std :: function <> kullanılması daha iyi olur mu?

Şu anda olduğu gibi, std :: set sadece bir kaptır, matematik anlamda kümenin uygulanması için çok uygundur, ancak std :: vector gibi teorik bir küme olmaktan neredeyse teorik bir vektör olmaktan uzaktır.