เหตุใด std :: set จึงไม่มีฟังก์ชันสมาชิก“ ประกอบด้วย”

ฉันใช้งานหนักstd::set<int>และบ่อยครั้งฉันต้องตรวจสอบว่าชุดดังกล่าวมีตัวเลขหรือไม่

ฉันคิดว่ามันเป็นธรรมชาติที่จะเขียน:

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

แต่เนื่องจากไม่มีcontainsสมาชิกฉันจึงต้องเขียนสิ่งที่ยุ่งยาก:

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

หรือไม่ชัดเจนเท่า:

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

มีเหตุผลในการตัดสินใจออกแบบนี้หรือไม่?

ฉันคิดว่ามันอาจจะเป็นเพราะพวกเขากำลังพยายามที่จะทำให้std::setและstd::multisetเป็นที่คล้ายกันที่เป็นไปได้ (และเห็นcountได้ชัดว่ามีความหมายที่เหมาะสมอย่างยิ่งสำหรับstd::multiset)

โดยส่วนตัวฉันคิดว่านี่เป็นความผิดพลาด

มันดูไม่แย่นักถ้าคุณแสร้งทำเป็นว่าcountเป็นเพียงการสะกดผิดcontainsและเขียนแบบทดสอบเป็น:

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

มันยังคงน่าเสียดายอยู่

เพื่อให้สามารถเขียนif (s.contains()), contains()มีการส่งกลับbool(หรือชนิดที่จะแปลงสภาพboolซึ่งเป็นอีกเรื่องหนึ่ง) เช่นbinary_searchไม่

เหตุผลพื้นฐานที่อยู่เบื้องหลังการตัดสินใจการออกแบบไม่ได้ที่จะทำมันด้วยวิธีนี้คือว่าcontains()ที่ส่งกลับboolจะสูญเสียข้อมูลที่มีค่าเกี่ยวกับการที่องค์ประกอบที่อยู่ในคอลเลกชัน find()เก็บรักษาและส่งคืนข้อมูลนั้นในรูปแบบของตัววนซ้ำดังนั้นจึงเป็นทางเลือกที่ดีกว่าสำหรับไลบรารีทั่วไปเช่น STL นี่เป็นหลักการชี้นำของ Alex Stepanov มาโดยตลอดอย่างที่เขาอธิบายบ่อยๆ (ตัวอย่างเช่นที่นี่ )

สำหรับcount()แนวทางโดยทั่วไปแม้ว่ามักจะเป็นวิธีแก้ปัญหาที่ถูกต้อง แต่ปัญหาก็คือมันทำงานได้ดีกว่า contains() จะต้องทำ

นั่นไม่ได้หมายความว่า a bool contains()ไม่ใช่สิ่งที่ดีที่จะมีหรือจำเป็นด้วยซ้ำ เมื่อไม่นานมานี้เราได้มีการอภิปรายเกี่ยวกับปัญหาเดียวกันนี้ในกลุ่ม ISO C ++ Standard - Future Proposals

มันขาดเพราะไม่มีใครเพิ่ม ไม่มีใครเพิ่มเนื่องจากคอนเทนเนอร์จาก STL ที่stdไลบรารีรวมไว้ซึ่งออกแบบมาให้มีส่วนต่อประสานน้อยที่สุด (สังเกตว่าstd::stringว่าไม่ได้มาจาก STL ในลักษณะเดียวกัน)

หากคุณไม่สนใจไวยากรณ์แปลก ๆ คุณสามารถปลอมได้:

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

ใช้:

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

โดยทั่วไปคุณสามารถเขียนวิธีการขยายสำหรับ C ++ ส่วนใหญ่ได้ stdประเภทโดยใช้เทคนิคนี้

มันสมเหตุสมผลกว่าที่จะทำสิ่งนี้:

if (some_set.count(some_element)) {
}

แต่ฉันรู้สึกสนุกกับวิธีการขยาย

สิ่งที่น่าเศร้าจริงๆคือการเขียนประสิทธิภาพcontainsอาจเร็วขึ้นบน a multimapหรือmultisetเพียงแค่ต้องหาองค์ประกอบเดียวในขณะcountที่ต้องหาแต่ละองค์ประกอบและนับและนับพวกเขา

ชุดหลายชุดที่มี 1 พันล้านชุดของ 7 (คุณรู้ไหมว่าในกรณีที่คุณหมด) อาจมีช้า.count(7)มาก แต่อาจมีเร็วมากcontains(7)แต่อาจมีความรวดเร็ว

ด้วยวิธีการขยายข้างต้นเราสามารถทำให้เร็วขึ้นสำหรับกรณีนี้โดยใช้lower_boundเปรียบเทียบกับendแล้วเปรียบเทียบกับองค์ประกอบ อย่างไรก็ตามการทำเช่นนั้นสำหรับแมวที่ไม่มีการเรียงลำดับเช่นเดียวกับแมวที่ได้รับคำสั่งจะต้องใช้ SFINAE แบบแฟนซีหรือการโอเวอร์โหลดเฉพาะคอนเทนเนอร์

คุณกำลังพิจารณาในบางกรณีและไม่เห็นภาพที่ใหญ่ขึ้น ตามที่ระบุไว้ในเอกสาร std::setเป็นไปตามข้อกำหนดของแนวคิดAssociativeContainer สำหรับแนวคิดนั้นมันไม่สมเหตุสมผลเลยที่จะมีcontainsวิธีการเพราะมันค่อนข้างไร้ประโยชน์สำหรับstd::multisetและstd::multimapแต่ก็countใช้ได้ดีสำหรับพวกเขาทั้งหมด แม้ว่าวิธีการcontainsอาจจะเพิ่มเป็นชื่อแทนสำหรับcountสำหรับstd::set, std::mapและรุ่นแฮชของพวกเขา (เช่นlengthสำหรับsize()ในstd::string) แต่ดูเหมือนว่าผู้สร้างห้องสมุดไม่เห็นความจำเป็นที่แท้จริงสำหรับมัน

แม้ว่าฉันไม่รู้ว่าทำไมstd::setไม่มีcontainsแต่countสิ่งที่เคยส่งกลับมาเท่านั้น0หรือ1คุณสามารถเขียนcontainsฟังก์ชันตัวช่วยเทมเพลตได้ดังนี้:

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

และใช้มันดังนี้:

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

เหตุผลที่แท้จริงsetเป็นเรื่องลึกลับสำหรับฉัน แต่คำอธิบายที่เป็นไปได้อย่างหนึ่งสำหรับการออกแบบเดียวกันนี้mapอาจเป็นการป้องกันไม่ให้ผู้คนเขียนโค้ดที่ไม่มีประสิทธิภาพโดยบังเอิญ:

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

ซึ่งจะทำให้เกิดการmapค้นหาสองครั้ง

แต่คุณถูกบังคับให้รับตัววนซ้ำ สิ่งนี้ช่วยให้คุณมีคำใบ้ว่าคุณควรใช้ตัววนซ้ำ:

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

ซึ่งใช้การmapค้นหาเพียงครั้งเดียว

เมื่อเราตระหนักถึงสิ่งนั้นsetและmapสร้างขึ้นจากเนื้อเดียวกันเราก็สามารถนำหลักการนี้ไปsetใช้ได้เช่นกัน นั่นคือหากเราต้องการดำเนินการกับรายการในsetกรณีที่มีอยู่ในการsetออกแบบนี้เท่านั้นการออกแบบนี้สามารถป้องกันไม่ให้เราเขียนโค้ดได้ดังนี้:

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

แน่นอนว่าทั้งหมดนี้เป็นเพียงการคาดเดาเท่านั้น

ตั้งแต่ c ++ 20

bool contains( const Key& key ) const

สามารถใช้ได้.

แล้ว 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;

มี () ต้องส่งคืนบูล การใช้คอมไพเลอร์ C ++ 20 ฉันได้รับผลลัพธ์ต่อไปนี้สำหรับโค้ด:

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

อีกเหตุผลหนึ่งคือมันจะทำให้โปรแกรมเมอร์เข้าใจผิดว่า std :: set คือเซตในความหมายของทฤษฎีเซตคณิตศาสตร์ หากพวกเขาใช้สิ่งนั้นจะมีคำถามอื่น ๆ ตามมา: ถ้าชุด std :: มี () สำหรับค่าทำไมมันถึงไม่มีสำหรับชุดอื่น ยูเนี่ยน (), จุดตัด () และการดำเนินการเซ็ตและเพรดิเคตอื่น ๆ อยู่ที่ไหน

คำตอบคือแน่นอนว่าการดำเนินการเซ็ตบางส่วนถูกนำไปใช้แล้วเป็นฟังก์ชันใน (std :: set_union () เป็นต้น) และอื่น ๆ จะถูกนำไปใช้งานเล็กน้อยตามที่มี () ฟังก์ชันและอ็อบเจกต์ฟังก์ชันทำงานร่วมกับนามธรรมทางคณิตศาสตร์ได้ดีกว่าสมาชิกอ็อบเจ็กต์และไม่ จำกัด เฉพาะคอนเทนเนอร์บางประเภท

หากจำเป็นต้องใช้ฟังก์ชันชุดคณิตศาสตร์เต็มรูปแบบเขาไม่เพียงมีตัวเลือกคอนเทนเนอร์พื้นฐานเท่านั้น แต่เขายังมีรายละเอียดการนำไปใช้งานอีกด้วยเช่นฟังก์ชัน theory_union () ของเขาจะทำงานกับวัตถุที่ไม่เปลี่ยนรูปได้หรือไม่ซึ่งเหมาะสำหรับการเขียนโปรแกรมเชิงฟังก์ชัน หรือจะแก้ไขตัวถูกดำเนินการและบันทึกหน่วยความจำ? มันจะถูกนำไปใช้เป็นวัตถุฟังก์ชันตั้งแต่เริ่มต้นหรือจะเป็นการดีกว่าที่จะใช้เป็นฟังก์ชัน C และใช้ std :: function <> ถ้าจำเป็น?

อย่างที่เป็นอยู่ตอนนี้ std :: set เป็นเพียงคอนเทนเนอร์ซึ่งเหมาะอย่างยิ่งสำหรับการนำ set ไปใช้ในความหมายทางคณิตศาสตร์ แต่มันเกือบจะห่างไกลจากการเป็นเซตทางทฤษฎีเช่น std :: vector จากการเป็นเวกเตอร์เชิงทฤษฎี