Почему 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;

contains () должен возвращать 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 есть contains () для значения, почему у него нет его для другого набора? Где объединение (), пересечение () и другие операции над множествами и предикаты?

Ответ, конечно же, заключается в том, что некоторые из заданных операций уже реализованы как функции в (std :: set_union () и т. Д.), А другие так же тривиально реализованы, как contains (). Функции и функциональные объекты лучше работают с математическими абстракциями, чем члены объектов, и они не ограничены конкретным типом контейнера.

Если кому-то нужно реализовать полную функциональность математического набора, у него есть не только выбор базового контейнера, но также выбор деталей реализации, например, будет ли его функция theory_union () работать с неизменяемыми объектами, лучше подходящими для функционального программирования , или он изменит свои операнды и сэкономит память? Будет ли он реализован как объект функции с самого начала или лучше реализовать C-функцию и использовать std :: function <> при необходимости?

На данный момент std :: set - это просто контейнер, хорошо подходящий для реализации set в математическом смысле, но он почти так же далек от теоретического набора, как std :: vector от теоретического вектора.