STL haritalarında map :: insert kullanmak [] 'den daha mı iyidir?

Bir süre önce, bir meslektaşımla STL haritalarına nasıl değer ekleyeceğimi tartıştım . map[key] = value; Doğal hissettiği ve okuması açık olduğu için tercih ettim , map.insert(std::make_pair(key, value))

Sadece sordum ve ikimiz de eklemenin neden daha iyi olduğunu hatırlayamıyoruz, ama eminim sadece bir stil tercihi değil, verimlilik gibi teknik bir neden de vardı. SGI STL referans basitçe "Açıkçası, bu üye işlev gereksizdir.: O sadece kolaylık var" diyor

Biri bana bu sebebi söyleyebilir mi, yoksa sadece bir tane olduğunu hayal ediyor muyum?

Yazdığın zaman

map[key] = value;

orada ayırt etmenin bir yolu değiştirilirvalue FOR keyveya eğer oluşturulan yeni keyolan value.

map::insert() yalnızca aşağıdakileri oluşturur:

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

Uygulamalarımın çoğu için, genellikle oluşturup oluşturmamayı veya değiştirmem umrumda değil, bu yüzden okumayı daha kolay kullanıyorum map[key] = value.

Haritada zaten mevcut olan anahtar söz konusu olduğunda, ikisinin farklı semantiği vardır. Yani gerçekten doğrudan karşılaştırılamazlar.

Ancak işleç [] sürümü varsayılan olarak değeri oluşturmayı ve sonra atamayı gerektirir, bu nedenle bu kopya kopyadan daha pahalıysa, daha pahalı olacaktır. Bazen varsayılan yapı anlamsızdır ve operatör [] sürümünü kullanmak imkansızdır.

Dikkat edilmesi gereken başka bir şey std::map:

myMap[nonExistingKey];haritada nonExistingKeyvarsayılan bir değere sıfırlanmış yeni bir giriş oluşturur .

Bu, ilk gördüğümde cehennemi korkuttu (başımı çok eski bir hataya karşı vurarak). Bunu beklemezdim. Bana göre, bu bir get işlemi gibi görünüyor ve "yan etki" beklemiyordum. map.find()Haritanızdan almayı tercih edin.

Varsayılan kurucunun performans isabeti bir sorun değilse, lütfen, tanrı sevgisi için daha okunabilir versiyona gidin.

:)

insert istisna güvenlik açısından daha iyidir.

İfade map[key] = valueaslında iki işlemdir:

1. map[key] - varsayılan değere sahip bir harita öğesi oluşturma.
2. = value - değerin o öğeye kopyalanması.

İkinci adımda bir istisna olabilir. Sonuç olarak, işlem sadece kısmen yapılacaktır (haritaya yeni bir eleman eklenmiştir, ancak bu eleman ile başlatılmamıştır.value ). Bir işlemin tamamlanmadığı, ancak sistem durumunun değiştirildiği duruma "yan etki" ile işlem denir.

insertoperasyon güçlü bir garanti verir, yan etkileri olmadığı anlamına gelir ( https://en.wikipedia.org/wiki/Exception_safety ). insertya tamamen yapılır ya da haritayı değiştirilmemiş durumda bırakır.

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

Tek bir eleman takılacaksa, istisna olması durumunda kapta değişiklik olmaz (güçlü garanti).

Uygulamanız hız açısından kritikse, orijinal nesnenin 2 tanesi geçici nesne olan ve er ya da geç olarak imha edilen toplam 3 kopyasını oluşturduğu için [] operatörünü kullanmanızı öneririm.

Ancak insert () 'de, orijinal nesnenin 4 kopyası oluşturulur ve bunların 3 tanesi geçici nesnelerdir (mutlaka "geçici" değil) ve yok edilir.

Bu, aşağıdakiler için ekstra zaman anlamına gelir: 1. Bir nesne bellek ayırma 2. Bir ekstra kurucu çağrı 3. Bir ekstra yıkıcı çağrı 4. Bir nesne bellek ayırma

Nesneleriniz büyükse, yapıcılar tipiktir, yıkıcılar çok fazla kaynak serbest bırakır, yukarıdaki noktalar daha da önemlidir. Okunabilirlik konusunda, her ikisinin de yeterince adil olduğunu düşünüyorum.

Aynı soru aklıma geldi ama aşırı okunabilirlik değil, hız. Burada bahsettiğim nokta hakkında bilmek için geldi bir örnek kod.

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

Şimdi c ++ 11 bir STL haritası bir çift eklemek için en iyi yolu olduğunu düşünüyorum:

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

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

Sonuç ile bir çift olacaktır:

• İlk öğe (sonuç.İlk), eklenen çifti işaret eder veya anahtar zaten varsa bu anahtarla çifti işaret eder.

• İkinci öğe (sonuç.saniye), ekleme doğru veya yanlışsa doğru bir şey ters gitti.

PS: sipariş hakkında dava yoksa std :: unordered_map;)

Teşekkürler!

Map :: insert () içeren bir gotcha, anahtar haritada zaten varsa bir değerin yerini almaz. Java programcıları tarafından yazıldıkları yerde Java'nın Map.put () ile aynı şekilde davranmasını bekledikleri değerlerin değiştirildiği C ++ kodunu gördüm.

Bir not da kullanabilirsiniz olmasıdır 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);
}

Burada , anahtar varsa değerin üzerine yazıldığını ancak varsa değerin operator[] üzerine yazılmadığını gösteren başka bir örnek verilmiştir ..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 ) ;

}

Bu oldukça kısıtlı bir durum, ancak aldığım yorumlardan yola çıkarak kayda değer olduğunu düşünüyorum.

Geçmişte insanların harita biçiminde kullandıklarını gördüm

map< const key, const val> Map;

yanlışlıkla değer üzerine yazma durumlarından kaçınmak, ancak daha sonra başka bazı kod parçalarında yazmaya devam etmek için:

const_cast< T >Map[]=val;

Hatırladıkları gibi bunu yapma nedenleri, bu belirli kod parçalarında harita değerlerinin üzerine yazmayacaklarından emindiler; dolayısıyla, daha 'okunabilir' yöntemle devam etmek[] .

Aslında bu insanlar tarafından yazılan koddan herhangi bir doğrudan sorun yaşamadım, ancak bugüne kadar risklerin - ne kadar küçük olsa da - kolayca önlenebilecekleri zaman alınmaması gerektiğini hissediyorum.

Üzerine kesinlikle yazılmaması gereken harita değerleri ile uğraşıyorsanız kullanın insert. Yalnızca okunabilirlik için istisna yapmayın.

Std :: map insert()işlevinin anahtarla ilişkili değerin üzerine yazmaması gerçeği, nesne numaralandırma kodunu şu şekilde yazmamızı sağlar:

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

Farklı benzersiz olmayan nesneleri 0..N aralığındaki bazı kimliklerle eşleştirmemiz gerektiğinde oldukça yaygın bir sorundur. Bu kimlikler daha sonra örneğin grafik algoritmalarında kullanılabilir. operator[]Bence alternatif daha az okunabilir görünecektir:

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