Чому 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. Це завжди було керівним принципом для Алекса Степанова, як він часто пояснював (наприклад, тут ).

Щодо count()підходу в цілому, хоча це часто нормальне вирішення, проблема з ним полягає в тому, що він робить більше роботи, ніж contains() доводиться робити .

Це не означає, що bool contains()це не дуже приємне або навіть необхідне. Нещодавно ми обговорили цю саму проблему в групі стандартів ISO C ++ - майбутні пропозиції.

Цього не вистачає, тому що ніхто не додав. Ніхто не додав його, тому що контейнери з 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)) {
}

В основному, ви можете написати методи розширення для більшості stdтипів C ++, використовуючи цю техніку.

Має набагато більше сенсу просто зробити це:

if (some_set.count(some_element)) {
}

але мене розважає метод розширення.

Дійсно сумно, що ефективне написання containsмогло б бути швидшим на 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;

містить () повинен повернути bool. Використовуючи компілятор 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 :: set містить () для значення, чому він не має його для іншого набору? Де знаходяться об'єднання (), перетин () та інші задані операції та предикати?

Відповідь, звичайно, полягає в тому, що деякі задані операції вже реалізовані як функції в (std :: set_union () і т.д.), а інші такі ж тривіально реалізовані, як і містить (). Функції та об'єкти функціонування краще працюють з математичними абстракціями, ніж члени об'єкта, і вони не обмежуються певним типом контейнера.

Якщо потрібно реалізувати повний функціонал математики, у нього є не лише вибір базового контейнера, але і він має вибір деталей реалізації, наприклад, чи буде функція його теорії_union () працювати з незмінними об'єктами, більш підходящими для функціонального програмування чи це змінило б операнди та зберегло пам'ять? Чи буде вона реалізована як об’єкт функції з самого початку, або було б краще реалізувати це C-функція, а при необхідності використовувати std :: function <>?

Як і зараз, std :: set - це просто контейнер, добре підходить для реалізації набору в математичному сенсі, але він майже далекий від теоретичного набору, оскільки std :: вектор від теоретичного вектора.