Czy w mapach STL lepiej jest używać map :: insert niż []?

Jakiś czas temu rozmawiałem z kolegą o tym, jak wstawiać wartości do map STL . Wolałem, map[key] = value; ponieważ wydaje się to naturalne i czytelne, podczas gdy on wolał map.insert(std::make_pair(key, value))

Właśnie go zapytałem i żadne z nas nie pamięta, dlaczego wkładka jest lepsza, ale jestem pewien, że nie była to tylko preferencja stylowa, a raczej powód techniczny, taki jak wydajność. Odniesienia SGI STL po prostu mówi „Ściśle mówiąc, ta funkcja jest niepotrzebna członkiem. Istnieje tylko dla wygody”

Czy ktoś może mi powiedzieć ten powód, czy tylko marzę, że jest taki powód?

Kiedy piszesz

map[key] = value;

nie ma sposobu, aby stwierdzić, czy otrzymuje się valueza keylub jeśli utworzony nowy keyz value.

map::insert() utworzy tylko:

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;
}

W przypadku większości moich aplikacji zwykle nie dbam o to, czy tworzę, czy wymieniam, więc używam łatwiejszego do odczytania map[key] = value.

Obie mają różną semantykę, jeśli chodzi o klucz już istniejący na mapie. Więc nie są tak naprawdę bezpośrednio porównywalne.

Ale wersja operatora [] wymaga domyślnego skonstruowania wartości, a następnie przypisania, więc jeśli jest to droższe niż konstrukcja kopiowania, to będzie droższe. Czasami domyślna konstrukcja nie ma sensu, a wtedy korzystanie z wersji operator [] byłoby niemożliwe.

Kolejna rzecz, na którą warto zwrócić uwagę std::map:

myMap[nonExistingKey];utworzy nowy wpis na mapie, kluczowany do nonExistingKeyzainicjowania na wartość domyślną.

To mnie przeraziło, gdy zobaczyłem to po raz pierwszy (uderzając głową o paskudnego robaka). Nie spodziewałbym się tego. Dla mnie wygląda to na operację get i nie spodziewałem się „efektu ubocznego”. Wolę, map.find()gdy wychodzisz z mapy.

Jeśli hit wydajności domyślnego konstruktora nie stanowi problemu, proszę, na miłość boską, przejdź do bardziej czytelnej wersji.

:)

insert jest lepszy z punktu widzenia bezpieczeństwa wyjątkowego.

Wyrażenie map[key] = valueto tak naprawdę dwie operacje:

1. map[key] - tworzenie elementu mapy z wartością domyślną.
2. = value - kopiowanie wartości do tego elementu.

Wyjątek może wystąpić na drugim etapie. W rezultacie operacja zostanie wykonana tylko częściowo (nowy element został dodany do mapy, ale tego elementu nie zainicjowano value). Sytuacja, w której operacja nie jest zakończona, ale stan systemu jest zmodyfikowany, nazywana jest operacją z „efektem ubocznym”.

insertoperacja daje silną gwarancję, oznacza, że ​​nie ma skutków ubocznych ( https://en.wikipedia.org/wiki/Exception_safety ). insertjest całkowicie gotowy lub pozostawia mapę w niezmodyfikowanym stanie.

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

Jeśli ma zostać wstawiony pojedynczy element, nie ma zmian w pojemniku w przypadku wyjątku (silna gwarancja).

Jeśli twoja aplikacja jest krytyczna pod względem szybkości, doradzę za pomocą operatora [], ponieważ tworzy ona w sumie 3 kopie oryginalnego obiektu, z których 2 są obiektami tymczasowymi i prędzej czy później zniszczonymi jako.

Ale w insert () tworzone są 4 kopie oryginalnego obiektu, z czego 3 są obiektami tymczasowymi (niekoniecznie „tymczasowymi”) i są niszczone.

Co oznacza dodatkowy czas na: 1. Przydział pamięci jednego obiektu 2. Jedno dodatkowe wywołanie konstruktora 3. Jedno dodatkowe wywołanie destruktora 4. Deallokacja pamięci jednego obiektu

Jeśli twoje obiekty są duże, konstruktory są typowe, destruktory uwalniają wiele zasobów, powyżej punktów liczy się jeszcze więcej. Jeśli chodzi o czytelność, uważam, że oba są wystarczająco uczciwe.

To samo pytanie przyszło mi do głowy, ale nie z powodu czytelności, ale szybkości. Oto przykładowy kod, dzięki któremu dowiedziałem się o punkcie, o którym wspomniałem.

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;
}

Teraz w c ++ 11 Myślę, że najlepszym sposobem wstawienia pary do mapy STL jest:

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

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

Wynik będzie para z:

• Pierwszy element (score.first) wskazuje na wstawioną parę lub wskaż parę za pomocą tego klucza, jeśli klucz już istnieje.

• Drugi element (wynik. Drugi), prawda, jeśli wstawienie było prawidłowe lub fałszywe, coś poszło nie tak.

PS: Jeśli nie masz wątpliwości co do kolejności, możesz użyć std :: unordered_map;)

Dzięki!

Gotcha z map :: insert () polega na tym, że nie zastąpi wartości, jeśli klucz już istnieje na mapie. Widziałem kod C ++ napisany przez programistów Java, w których spodziewali się, że insert () będzie zachowywać się tak samo jak Map.put () w Javie, gdzie wartości są zamieniane.

Jedna uwaga jest taka, że ​​możesz także użyć funkcji Boost .

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);
}

Oto kolejny przykład pokazujący, że operator[] nadpisuje wartość klucza, jeśli istnieje, ale .insert nie nadpisuje wartości, jeśli istnieje.

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 ) ;

}

Jest to raczej ograniczony przypadek, ale sądząc z otrzymanych komentarzy, myślę, że warto to zauważyć.

W przeszłości widziałem ludzi używających map w formie

map< const key, const val> Map;

aby uniknąć przypadków przypadkowego zastąpienia wartości, ale pisz dalej w kilku innych fragmentach kodu:

const_cast< T >Map[]=val;

Powodem, dla którego to zrobiłem, jak pamiętam, było to, że byli pewni, że w tych określonych fragmentach kodu nie zamierzają nadpisywać wartości map; stąd kontynuacja bardziej „czytelnej” metody[] .

Tak naprawdę nigdy nie miałem bezpośrednich problemów z kodem napisanym przez tych ludzi, ale do tej pory mocno odczuwam, że ryzyko - jakkolwiek małe - nie powinno być podejmowane, gdy można go łatwo uniknąć.

W przypadkach, gdy masz do czynienia z wartościami mapy, których absolutnie nie wolno nadpisywać, użyj insert. Nie rób wyjątków tylko dla czytelności.

Fakt, że insert()funkcja std :: map nie zastępuje wartości powiązanej z kluczem, pozwala nam napisać kod wyliczenia obiektu w następujący sposób:

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

Jest to dość powszechny problem, gdy musimy mapować różne nieunikalne obiekty na niektóre identyfikatory w zakresie 0..N. Te identyfikatory można później wykorzystać na przykład w algorytmach graficznych. operator[]Moim zdaniem alternatywa z wyglądałaby mniej czytelnie:

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