Di STL maps, apakah lebih baik menggunakan map :: insert daripada []?

Beberapa waktu yang lalu, saya berdiskusi dengan seorang kolega tentang cara memasukkan nilai dalam peta STL . Saya lebih suka map[key] = value; karena rasanya alami dan jelas untuk membaca sedangkan dia lebih suka map.insert(std::make_pair(key, value))

Saya hanya bertanya kepadanya dan kami berdua tidak dapat mengingat alasan mengapa memasukkan lebih baik, tetapi saya yakin itu bukan hanya preferensi gaya melainkan ada alasan teknis seperti efisiensi. The referensi SGI STL hanya mengatakan "Sebenarnya, fungsi anggota ini tidak diperlukan. Itu ada hanya untuk kenyamanan"

Adakah yang bisa memberi tahu saya alasan itu, atau saya hanya bermimpi ada satu?

Ketika Anda menulis

map[key] = value;

tidak ada cara untuk mengetahui apakah Anda diganti yang valueuntuk key, atau jika Anda dibuat baru keydengan value.

map::insert() hanya akan membuat:

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

Untuk sebagian besar aplikasi saya, saya biasanya tidak peduli apakah saya membuat atau mengganti, jadi saya menggunakan yang lebih mudah dibaca map[key] = value.

Keduanya memiliki semantik yang berbeda ketika datang ke kunci yang sudah ada di peta. Jadi mereka tidak bisa dibandingkan secara langsung.

Tetapi versi operator [] memerlukan nilai konstruk default, dan kemudian menetapkan, jadi jika ini lebih mahal daripada menyalin konstruksi, maka itu akan lebih mahal. Terkadang konstruksi default tidak masuk akal, dan kemudian tidak mungkin menggunakan versi operator [].

Hal lain yang perlu diperhatikan std::map:

myMap[nonExistingKey];akan membuat entri baru di peta, dikunci untuk nonExistingKeydiinisialisasi ke nilai default.

Ini membuatku takut saat pertama kali aku melihatnya (sambil membenturkan kepalaku ke bug warisan yang mengerikan). Tidak akan diharapkan itu. Bagi saya, itu terlihat seperti operasi, dan saya tidak mengharapkan "efek samping." Lebih suka map.find()saat mendapatkan dari peta Anda.

Jika hit kinerja dari konstruktor default tidak menjadi masalah, silakan, untuk cinta tuhan, pergi dengan versi yang lebih mudah dibaca.

:)

insert lebih baik dari sudut keamanan pengecualian.

Ekspresi map[key] = valuesebenarnya adalah dua operasi:

1. map[key] - membuat elemen peta dengan nilai default.
2. = value - menyalin nilai ke elemen itu.

Pengecualian dapat terjadi pada langkah kedua. Akibatnya operasi hanya akan dilakukan sebagian (elemen baru ditambahkan ke peta, tetapi elemen itu tidak diinisialisasi dengan value). Situasi ketika suatu operasi tidak lengkap, tetapi keadaan sistem dimodifikasi, disebut operasi dengan "efek samping".

insertoperasi memberikan jaminan yang kuat, berarti tidak memiliki efek samping ( https://en.wikipedia.org/wiki/Exception_safety ). insertbaik dilakukan sepenuhnya atau meninggalkan peta dalam keadaan tidak dimodifikasi.

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

Jika satu elemen dimasukkan, tidak ada perubahan dalam wadah jika terkecuali (jaminan kuat).

Jika aplikasi Anda sangat kritis, saya akan menyarankan menggunakan operator [] karena itu membuat total 3 salinan dari objek asli yang 2 di antaranya adalah objek sementara dan cepat atau lambat dihancurkan sebagai.

Namun dalam sisipan (), 4 salinan dari objek asli dibuat dari mana 3 adalah objek sementara (tidak harus "temporer") dan dihancurkan.

Yang berarti waktu tambahan untuk: 1. Alokasi memori satu objek 2. Satu panggilan konstruktor ekstra 3. Satu panggilan destruktor tambahan 4. Satu objek memori deallokasi

Jika objek Anda besar, konstruktor adalah tipikal, destruktor melakukan banyak pembebasan sumber daya, poin di atas bahkan lebih diperhitungkan. Mengenai keterbacaan, saya pikir keduanya cukup adil.

Pertanyaan yang sama muncul di benak saya tetapi tidak terlalu mudah dibaca tetapi kecepatan. Berikut adalah contoh kode yang saya gunakan untuk mengetahui poin yang saya sebutkan.

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

Sekarang di c ++ 11 saya berpikir bahwa cara terbaik untuk memasukkan pasangan dalam peta STL adalah:

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

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

The Hasilnya akan menjadi pasangan dengan:

• Elemen pertama (result.first), menunjuk ke pasangan yang dimasukkan atau menunjuk ke pasangan dengan kunci ini jika kunci sudah ada.

• Elemen kedua (result.second), benar jika penyisipan itu benar atau salah itu ada sesuatu yang salah.

PS: Jika Anda tidak perlu memesan, Anda dapat menggunakan std :: unordered_map;)

Terima kasih!

Gotcha dengan map :: insert () adalah tidak akan mengganti nilai jika kunci sudah ada di peta. Saya telah melihat kode C ++ yang ditulis oleh programmer Java di mana mereka mengharapkan insert () untuk berperilaku seperti Map.put () di Java di mana nilainya diganti.

Satu catatan adalah bahwa Anda juga dapat menggunakan Boost. Tugas :

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

Berikut adalah contoh lain, menunjukkan bahwa operator[] menimpa nilai untuk kunci jika ada, tetapi .insert tidak menimpa nilai jika ada.

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

}

Ini adalah kasus yang agak terbatas, tetapi menilai dari komentar yang saya terima saya pikir itu perlu diperhatikan.

Saya pernah melihat orang di masa lalu menggunakan peta dalam bentuk

map< const key, const val> Map;

untuk menghindari kasus penimpaan nilai yang tidak disengaja, tetapi kemudian lanjutkan menulis dalam beberapa bit kode lainnya:

const_cast< T >Map[]=val;

Alasan mereka untuk melakukan ini seingat saya adalah karena mereka yakin bahwa dalam bit kode tertentu mereka tidak akan menimpa nilai peta; karenanya, maju dengan metode yang lebih 'mudah dibaca' [].

Saya tidak pernah benar-benar mengalami masalah langsung dari kode yang ditulis oleh orang-orang ini, tetapi saya sangat merasa sampai hari ini bahwa risiko - betapapun kecilnya - tidak boleh diambil ketika mereka dapat dengan mudah dihindari.

Dalam kasus di mana Anda berurusan dengan nilai peta yang benar - benar tidak boleh ditimpa, gunakan insert. Jangan membuat pengecualian hanya untuk keterbacaan.

Fakta bahwa insert()fungsi std :: map tidak menimpa nilai yang terkait dengan kunci memungkinkan kita untuk menulis kode enumerasi objek seperti ini:

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

Ini adalah masalah yang cukup umum ketika kita perlu memetakan objek non-unik yang berbeda ke beberapa id dalam rentang 0..N. Id tersebut dapat digunakan nanti, misalnya, dalam algoritma grafik. Alternatif dengan operator[]akan terlihat kurang mudah dibaca menurut saya:

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