Чи краще на картах 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ініціалізації до значення за замовчуванням.

Це мене налякало пекло в перший раз, коли я його побачив (в той час як стукав головою об гнівний спадщину). Не очікував би цього. Для мене це виглядає як операція отримання, і я не очікував "побічного ефекту". Віддайте перевагу, 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 - тимчасові об'єкти і рано чи пізно знищуються як.

Але у вставці () створено 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), вірний, якщо вставлення було правильним чи хибним, щось пішло не так.

PS: Якщо у вас немає справи щодо замовлення, ви можете використовувати std :: unordered_map;)

Дякую!

Готча з map :: insert () полягає в тому, що вона не замінить значення, якщо ключ вже існує на карті. Я бачив код C ++, написаний програмістами Java, де вони очікували, що вставка () поводитиметься так само, як 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; 
}