Tại sao std :: set không có hàm thành viên “chứa”?

Tôi đang sử dụng rất nhiều std::set<int>và thường tôi chỉ cần kiểm tra xem một bộ như vậy có chứa một số hay không.

Tôi thấy thật tự nhiên khi viết:

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

Nhưng vì thiếu containsthành viên nên viết rườm rà:

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

hoặc không rõ ràng:

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

Có một lý do cho quyết định thiết kế này?

Tôi nghĩ có lẽ là do họ đang cố gắng tạo ra std::setvà std::multisetcàng giống càng tốt. (Và rõ ràng là countcó một ý nghĩa hoàn toàn hợp lý cho std::multiset.)

Cá nhân tôi nghĩ rằng đây là một sai lầm.

Sẽ không tệ lắm nếu bạn giả vờ đó countchỉ là lỗi chính tả containsvà viết bài kiểm tra là:

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

Nó vẫn còn là một sự xấu hổ.

Để có thể viết if (s.contains()), contains()phải trả về một bool(hoặc một loại có thể chuyển đổi thành boolmột câu chuyện khác), giống như binary_searchvậy.

Các lý do cơ bản đằng sau những quyết định thiết kế không để làm điều đó theo cách này là contains()trả về một boolsẽ mất thông tin có giá trị về nơi nguyên tố này là trong bộ sưu tập . find()bảo toàn và trả về thông tin đó dưới dạng một trình lặp, do đó là lựa chọn tốt hơn cho một thư viện chung như STL. Đây luôn là nguyên tắc chỉ đạo cho Alex Stepanov, như anh ấy đã thường giải thích (ví dụ: ở đây ).

Đối với count()cách tiếp cận nói chung, mặc dù nó thường là một cách giải quyết ổn, nhưng vấn đề với nó là nó hoạt động nhiều hơn contains() những gì phải làm .

Điều đó không có nghĩa là một bool contains()không phải là một thứ rất đẹp để có hoặc thậm chí là cần thiết. Cách đây ít lâu, chúng ta đã có một cuộc thảo luận dài về vấn đề tương tự này trong nhóm Tiêu chuẩn ISO C ++ - Đề xuất trong tương lai.

Nó thiếu nó bởi vì không ai thêm nó. Không ai thêm nó vì các vùng chứa từ STL mà stdthư viện đã kết hợp ở nơi được thiết kế để tối giản về giao diện. (Lưu ý rằng điều đó std::stringkhông đến từ STL theo cách tương tự).

Nếu bạn không nhớ một số cú pháp lạ, bạn có thể giả mạo nó:

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

sử dụng:

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

Về cơ bản, bạn có thể viết các phương thức mở rộng cho hầu hết các loại C ++ stdbằng cách sử dụng kỹ thuật này.

Sẽ có nhiều ý nghĩa hơn nếu chỉ làm điều này:

if (some_set.count(some_element)) {
}

nhưng tôi thích thú với phương pháp phương pháp mở rộng.

Điều thực sự đáng buồn là viết một hiệu quả containscó thể nhanh hơn trên một multimaphoặc multiset, vì họ chỉ phải tìm một phần tử, trong khi countphải tìm từng phần tử và đếm chúng .

Một bộ đa có chứa 1 tỷ bản sao của 7 (bạn biết đấy, trong trường hợp bạn hết) có thể thực sự chậm .count(7), nhưng có thể rất nhanhcontains(7) .

Với phương pháp mở rộng ở trên, chúng ta có thể thực hiện nhanh hơn cho trường hợp này bằng cách sử dụng lower_bound, so sánh với endvà sau đó so sánh với phần tử. Tuy nhiên, làm điều đó đối với meo không có thứ tự cũng như meo có thứ tự sẽ yêu cầu SFINAE ưa thích hoặc quá tải dành riêng cho thùng chứa.

Bạn đang xem xét trường hợp cụ thể và không nhìn thấy bức tranh lớn hơn. Như đã nêu trong tài liệu std::set đáp ứng yêu cầu của khái niệm AssociativeContainer . Đối với khái niệm đó, không có ý nghĩa gì khi có containsphương pháp, vì nó khá vô dụng đối với std::multisetvà std::multimap, nhưng counthoạt động tốt cho tất cả chúng. Mặc dù phương pháp containscó thể được thêm vào như là một bí danh cho countcho std::set, std::mapvà các phiên bản băm của họ (như lengthcho size()trong std::string), nhưng có vẻ như người sáng tạo thư viện không thấy nhu cầu thực sự cho nó.

Mặc dù tôi không biết tại sao std::setkhông có containsnhưng countnó chỉ trả về 0hoặc 1, bạn có thể viết một containshàm trợ giúp mẫu như thế này:

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

Và sử dụng nó như thế này:

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

Đối setvới tôi, lý do thực sự là một bí ẩn, nhưng một lời giải thích khả dĩ cho thiết kế tương tự này mapcó thể là ngăn mọi người tình cờ viết mã kém hiệu quả:

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

Điều này sẽ dẫn đến hai map tra cứu.

Thay vào đó, bạn buộc phải có một trình lặp. Điều này cung cấp cho bạn một gợi ý tinh thần rằng bạn nên sử dụng lại trình lặp:

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

mà chỉ cần một lần maptra cứu.

Khi chúng ta nhận ra điều đó setvà mapđược làm từ cùng một xác thịt, chúng ta cũng có thể áp dụng nguyên tắc này cho set. Có nghĩa là, nếu chúng ta muốn thực hiện một mục setduy nhất nếu nó có trong set, thiết kế này có thể ngăn chúng ta viết mã như sau:

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

Tất nhiên tất cả những điều này chỉ là suy đoán.

Kể từ c ++ 20,

bool contains( const Key& key ) const

có sẵn.

Còn binary_search thì sao?

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

chứa () phải trả về bool. Sử dụng trình biên dịch C ++ 20, tôi nhận được đầu ra sau cho mã:

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

Một lý do khác là nó sẽ tạo cho một lập trình viên ấn tượng sai lầm rằng std :: set là một tập hợp theo nghĩa lý thuyết tập hợp toán học. Nếu họ triển khai điều đó, thì nhiều câu hỏi khác sẽ theo sau: nếu một std :: set có chứa () cho một giá trị, tại sao nó không có nó cho một tập hợp khác? Các phép toán và vị từ union (), giao () và các tập hợp khác ở đâu?

Tất nhiên, câu trả lời là một số hoạt động tập hợp đã được triển khai dưới dạng các hàm trong (std :: set_union (), v.v.) và các hoạt động khác được triển khai nhỏ như hàm chứa (). Các hàm và các đối tượng hàm hoạt động tốt hơn với các trừu tượng toán học so với các thành viên đối tượng và chúng không bị giới hạn ở loại vùng chứa cụ thể.

Nếu một người cần triển khai một chức năng tập hợp toán học đầy đủ, anh ta không chỉ có lựa chọn vùng chứa bên dưới mà còn có lựa chọn chi tiết triển khai, ví dụ: liệu hàm theory_union () của anh ta có hoạt động với các đối tượng không thay đổi, phù hợp hơn với lập trình hàm không , hay nó sẽ sửa đổi các toán hạng và tiết kiệm bộ nhớ? Nó sẽ được triển khai dưới dạng đối tượng hàm ngay từ đầu hay tốt hơn nên triển khai là một hàm C và sử dụng std :: function <> nếu cần?

Như hiện tại, std :: set chỉ là một vùng chứa, rất phù hợp cho việc triển khai set theo nghĩa toán học, nhưng nó gần như là một tập lý thuyết như std :: vector từ việc trở thành một vector lý thuyết.