В картах STL лучше использовать map :: insert, чем []?

Некоторое время назад у меня была дискуссия с коллегой о том, как вставить значения в карты STL . Я предпочел, map[key] = value; потому что это естественно и понятно для чтения, тогда как он предпочитал map.insert(std::make_pair(key, value))

Я просто спросил его, и никто из нас не может вспомнить причину, по которой вставка лучше, но я уверен, что это был не просто стиль, а техническая причина, например, эффективность. Ссылка SGI STL просто говорит : «Строго говоря, эта функция - член не является необходимым: она существует только для удобства.»

Кто-нибудь может сказать мне эту причину, или я просто мечтаю, что она есть?

Когда пишешь

map[key] = value;

нет никакого способа узнать , если вы заменили на valueFOR key, или если вы создали новый keyс value.

map::insert() создаст только:

using std::cout; using std::endl;
typedef std::map<int, std::string> MyMap;
MyMap map;
// ...
std::pair<MyMap::iterator, bool> res = map.insert(MyMap::value_type(key,value));
if ( ! res.second ) {
    cout << "key " <<  key << " already exists "
         << " with value " << (res.first)->second << endl;
} else {
    cout << "created key " << key << " with value " << value << endl;
}

Для большинства моих приложений меня обычно не волнует, создаю я или заменяю, поэтому я использую более легкое для чтения map[key] = value.

Они имеют разную семантику, когда дело доходит до ключа, уже существующего на карте. Так что они на самом деле не сопоставимы напрямую.

Но версия оператора [] требует создания значения по умолчанию, а затем присвоения, поэтому, если это дороже, чем копирование, то это будет дороже. Иногда конструкция по умолчанию не имеет смысла, и тогда было бы невозможно использовать версию operator [].

Еще одна вещь, чтобы отметить с std::map:

myMap[nonExistingKey];создаст новую запись на карте, привязанную к nonExistingKeyинициализированному значению по умолчанию.

Это испугало меня до чертиков, когда я впервые увидел это (пока бился головой об ужасно унаследованную ошибку). Не ожидал этого. Для меня это выглядит как операция get, и я не ожидал «побочного эффекта». Предпочитаю map.find()при получении с вашей карты.

Если снижение производительности конструктора по умолчанию не является проблемой, пожалуйста, ради бога, используйте более читаемую версию.

:)

insert Лучше с точки зрения безопасности.

Выражение map[key] = valueна самом деле две операции:

1. map[key] - создание элемента карты со значением по умолчанию.
2. = value - копирование значения в этот элемент.

Исключение может произойти на втором этапе. В результате операция будет выполнена только частично (новый элемент был добавлен в карту, но этот элемент не был инициализирован сvalue ). Ситуация, когда операция не завершена, но состояние системы изменено, называется операцией с «побочным эффектом».

insertоперация дает надежную гарантию, означает, что она не имеет побочных эффектов ( https://en.wikipedia.org/wiki/Exception_safety ). insertлибо полностью выполнен, либо оставляет карту в неизмененном состоянии.

http://www.cplusplus.com/reference/map/map/insert/ :

Если нужно вставить один элемент, в контейнере нет изменений в случае исключения (строгая гарантия).

Если ваше приложение критично к скорости, я посоветую использовать оператор [], поскольку он создает всего 3 копии исходного объекта, из которых 2 являются временными объектами и рано или поздно уничтожаются как.

Но в insert () создаются 4 копии исходного объекта, из которых 3 являются временными объектами (не обязательно «временными») и уничтожаются.

Что означает дополнительное время для: 1. Выделения памяти для одного объекта 2. Один дополнительный вызов конструктора 3. Один дополнительный вызов деструктора 4. Выделение памяти одного объекта

Если ваши объекты большие, конструкторы типичны, деструкторы много освобождают от ресурсов, а количество очков выше еще больше. Что касается читабельности, я думаю, что оба достаточно справедливы.

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

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair<int,Sample>( 1, sample) );
    //map[1] = sample;
    return 0;
}

Теперь в C ++ 11 я думаю, что лучший способ вставить пару в карту STL:

typedef std::map<int, std::string> MyMap;
MyMap map;

auto& result = map.emplace(3,"Hello");

Результат будет пара с:

• Первый элемент (result.first), указывает на вставленную пару или указывает на пару с этим ключом, если ключ уже существует.

• Второй элемент (result.second), true, если вставка была правильной или ложной, что-то пошло не так.

PS: Если у вас нет дела по поводу заказа, вы можете использовать std :: unordered_map;)

Спасибо!

Гвоздь с map :: insert () состоит в том, что он не заменит значение, если ключ уже существует на карте. Я видел код C ++, написанный Java-программистами, где они ожидали, что insert () будет вести себя так же, как Map.put () в Java, где значения заменяются.

Обратите внимание, что вы также можете использовать Boost.Assign :

using namespace std;
using namespace boost::assign; // bring 'map_list_of()' into scope

void something()
{
    map<int,int> my_map = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);
}

Вот еще один пример, показывающий, что значение ключа operator[] перезаписывается, если оно существует, но.insert не перезаписывает значение , если оно существует.

void mapTest()
{
  map<int,float> m;


  for( int i = 0 ; i  <=  2 ; i++ )
  {
    pair<map<int,float>::iterator,bool> result = m.insert( make_pair( 5, (float)i ) ) ;

    if( result.second )
      printf( "%d=>value %f successfully inserted as brand new value\n", result.first->first, result.first->second ) ;
    else
      printf( "! The map already contained %d=>value %f, nothing changed\n", result.first->first, result.first->second ) ;
  }

  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

  /// now watch this.. 
  m[5]=900.f ; //using operator[] OVERWRITES map values
  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

}

Это довольно ограниченный случай, но, судя по комментариям, которые я получил, думаю, стоит отметить.

Я видел людей в прошлом, использующих карты в форме

map< const key, const val> Map;

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

const_cast< T >Map[]=val;

Их причина сделать это, насколько я помню, заключалась в том, что они были уверены, что в этих определенных фрагментах кода они не будут перезаписывать значения карты; следовательно, идти вперед с более «читабельным» методом[] .

На самом деле у меня никогда не было прямых проблем с кодом, написанным этими людьми, но до сегодняшнего дня я твердо чувствую, что риски - пусть даже небольшие - не должны приниматься, когда их легко избежать.

В случаях, когда вы имеете дело со значениями карты, которые абсолютно не должны быть перезаписаны, используйте insert. Не делайте исключений просто для удобства чтения.

Тот факт, что insert()функция std :: map не перезаписывает значение, связанное с ключом, позволяет нам писать код перечисления объектов следующим образом:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    dict.insert(make_pair(word, dict.size()));
}

Это довольно распространенная проблема, когда нам нужно сопоставить разные неуникальные объекты с некоторыми идентификаторами в диапазоне 0..N. Эти идентификаторы могут быть позже использованы, например, в алгоритмах графа. Альтернатива с operator[]будет выглядеть менее читабельным на мой взгляд:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    size_t sz = dict.size();
    if (!dict.count(word))
        dict[word] = sz; 
}