Обоснование семантики вставки карты std в C ++?

Я не знаю официального обоснования, но хотел бы отметить двойственность с operator[].

Кажется очевидным, что хотелось бы двух вариантов вставки:

• чисто аддитивный
• аддитивный / деструктивный

Если мы рассматриваем map как разреженное представление массива, то наличие operator[] имеет смысл. Я не знаю, существовали ли ранее существовавшие словари и диктовали ли этот синтаксис (возможно, почему бы и нет).

Кроме того, все контейнеры STL имеют несколько перегрузок insert, и это сходство интерфейсов - то, что позволяет универсальное программирование.

Следовательно, у нас есть как минимум два претендента на API: operator[] и insert.

Теперь, в C ++, если вы прочитаете:

array[4] = 5;

Естественно, что содержимое ячейки с индексом 4 было деструктивно обновлено. Таким образом, вполне естественно, что map::operator[] должен возвращать ссылку, чтобы разрешить это деструктивное обновление.

На этом этапе нам также нужна чисто аддитивная версия, и у нас есть этот insert метод. Почему нет ?

Конечно, можно было задать insert ту же семантику, что и operator[], а затем реализовать insert_or_ignore метод наверху. Хотя это было бы больше работы.

Поэтому, хотя я согласен с тем, что это может быть удивительно, я думаю, что мои рассуждения не слишком ошибочны и могут быть вероятным объяснением обстоятельств, которые привели нас сюда :)

Что касается предложенных вами альтернатив:

• вставить, UB, если уже существует

К счастью, это не так!

• вставить, выдать ошибку, если она уже существует

Только Java (и производные от нее) безумны. C ++ был задуман в то время, когда исключения использовались в исключительных обстоятельствах.

• вставить, заменить, если уже существует
• вставить, игнорировать, если уже существует (это поведение std :: map)

Мы согласны с тем, что выбор был между одним из них. Обратите внимание, что даже несмотря на то, что map выбрал второй вариант, он не полностью игнорирует тот факт, что элемент уже существует, по крайней мере, в версии с одним элементом, поскольку предупреждает, что элемент не был вставлен.

Метод вставки - это просто не то, что вы ищете, это звучит как ... Метод вставки предназначен для выполнения именно того, что подразумевает название ... вставки значений. Я согласен с тем, что возможность создать значение, если его еще нет, и заменить то, которое есть, в некоторых ситуациях важна, но в других вы бы просто предпочли не обрабатывать исключения, возвращаемые значения и т. Д., Если вы просто хотите сделать вставку, только если значение еще не указано.

Похоже, что метод, который вы ищете (как указано выше в BoBTFish), вероятно, является оператором []. Просто используйте это так:

myMap["key"] = "value";

Это пройдёт по вашей карте, найдет ключ «ключ» и заменит соответствующее значение на «значение». Если ключа нет, он его создаст. Оба метода очень полезны в разных ситуациях, и я обнаружил, что использую оба только в зависимости от того, что мне нужно.

Я не утверждаю, что знаю исходное обоснование решения, но придумать его несложно. Я думаю ;-)

Текущее поведение «вставить или игнорировать» позволяет очень легко реализовать два других - по крайней мере, для тех из нас, кто не боится создания и использования функций, не являющихся членами, для дополнения функциональности стандартной библиотеки («это не ООП- у достаточно! ").

Пример (написано на месте, поэтому могут быть ошибки):

template<typename Map>
void insert_or_update(Map& map, typename Map::value_type const& x)
{
  std::pair<typename Map::iterator, bool> result = map.insert(x);
  if (!result.second)
    result.first->second = x.second; // or throw an exception (consider using
                                     // a different function name, though)
}

Обратите внимание, что как есть, приведенная выше функция на самом деле не сильно отличается от operator[] - да, она избегает инициализации по умолчанию, но в то же время (потому что я ленив) она не может извлечь выгоду из семантики перемещения, которую вы выполняете. -date STL, вероятно, уже поддерживает operator[].

В любом случае, любое другое поведение вставки для map сделало бы его более утомительным для реализации других, поскольку map::find возвращает только конечный дозорный, если ключ еще не находится на карте. Конечно, с помощью <algorithm> (и особенно lower_bound) можно было бы писать эффективные вспомогательные функции, не утопая их в деталях реализации и уродливых общих конструкциях, таких как циклы ;-).

Начиная с insert() вы не ожидаете, что будут затронуты существующие объекты в контейнере. Поэтому простое их не трогает.

pair<iterator,bool> ‹- часть bool не говорит об успешной вставке или нет?

Вы можете просто обновить часть значения возвращаемого итератора, если часть bool имеет значение false, чтобы обновить существующий элемент с тем же ключом.