Apakah aman untuk push_back elemen dari vektor yang sama?

vector<int> v;
v.push_back(1);
v.push_back(v[0]);

Jika push_back kedua menyebabkan realokasi, referensi ke integer pertama dalam vektor tidak akan lagi valid. Jadi ini tidak aman?

vector<int> v;
v.push_back(1);
v.reserve(v.size() + 1);
v.push_back(v[0]);

Ini membuatnya aman?

Sepertinya http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526 mengatasi masalah ini (atau sesuatu yang sangat mirip dengannya) sebagai kemungkinan cacat pada standar:

1) Parameter yang diambil oleh referensi const dapat diubah selama pelaksanaan fungsi

Contoh:

Diberi std :: vector v:

v.insert (v.begin (), v [2]);

v [2] dapat diubah dengan menggerakkan elemen vektor

Resolusi yang diusulkan adalah bahwa ini bukan cacat:

vector :: insert (iter, value) diperlukan untuk bekerja karena standar tidak memberikan izin agar tidak berfungsi.

Ya, itu aman, dan implementasi perpustakaan standar melompat melalui lingkaran untuk membuatnya begitu.

Saya percaya pelaksana melacak persyaratan ini kembali ke 23.2 / 11 entah bagaimana, tapi saya tidak tahu caranya, dan saya juga tidak bisa menemukan sesuatu yang lebih konkret. Yang terbaik yang bisa saya temukan adalah artikel ini:

http://www.drdobbs.com/cpp/copying-container-elements-from-the-c-li/240155771

Pemeriksaan implementasi libc ++ dan libstdc ++ menunjukkan bahwa mereka juga aman.

Standar ini menjamin bahkan contoh pertama Anda menjadi aman. Mengutip C ++ 11

[sequence.reqmts]

3 Dalam Tabel 100 dan 101 ... Xmenunjukkan kelas wadah urutan, amenunjukkan nilai Xelemen yang mengandung tipe T, ... tmenunjukkan nilai lv atau nilai konstanta dariX::value_type

16 Tabel 101 ...

Ekspresi a.push_back(t) Jenis pengembalian void Semantik operasional Menambahkan salinan t. Membutuhkan: T akan CopyInsertablemenjadi X. Kontainer basic_string , deque, list,vector

Jadi, meskipun itu tidak sepele, implementasi harus menjamin itu tidak akan membatalkan referensi ketika melakukan push_back.

Tidak jelas bahwa contoh pertama aman, karena implementasi paling sederhana push_backadalah dengan terlebih dahulu realokasi vektor, jika perlu, dan kemudian menyalin referensi.

Tetapi setidaknya tampaknya aman dengan Visual Studio 2010. Implementasinya push_backmelakukan penanganan khusus kasus ketika Anda menekan kembali suatu elemen dalam vektor. Kode ini disusun sebagai berikut:

void push_back(const _Ty& _Val)
    {   // insert element at end
    if (_Inside(_STD addressof(_Val)))
        {   // push back an element
                    ...
        }
    else
        {   // push back a non-element
                    ...
        }
    }

Ini bukan jaminan dari standar, tetapi sebagai titik data lain, v.push_back(v[0])aman untuk libc ++ LLVM .

libc ++std::vector::push_back panggilan __push_back_slow_pathketika perlu merealokasi memori:

void __push_back_slow_path(_Up& __x) {
  allocator_type& __a = this->__alloc();
  __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), 
                                                  size(), 
                                                  __a);
  // Note that we construct a copy of __x before deallocating
  // the existing storage or moving existing elements.
  __alloc_traits::construct(__a, 
                            _VSTD::__to_raw_pointer(__v.__end_), 
                            _VSTD::forward<_Up>(__x));
  __v.__end_++;
  // Moving existing elements happens here:
  __swap_out_circular_buffer(__v);
  // When __v goes out of scope, __x will be invalid.
}

Versi pertama jelas TIDAK aman:

Operasi pada iterator yang diperoleh dengan memanggil wadah perpustakaan standar atau fungsi anggota string dapat mengakses wadah yang mendasarinya, tetapi tidak boleh memodifikasinya. [Catatan: Secara khusus, operasi kontainer yang membatalkan iterator bertentangan dengan operasi pada iterator yang terkait dengan kontainer itu. - catatan akhir]

dari bagian 17.6.5.9

Perhatikan bahwa ini adalah bagian tentang perlombaan data, yang biasanya dipikirkan orang bersamaan dengan threading ... tetapi definisi sebenarnya melibatkan hubungan "terjadi sebelum", dan saya tidak melihat adanya hubungan pemesanan antara beberapa efek samping push_backdi bermain di sini, yaitu pembatalan referensi tampaknya tidak didefinisikan sebagai diperintahkan sehubungan dengan menyalin-membangun elemen ekor baru.

Benar-benar aman.

Dalam contoh kedua yang Anda miliki

v.reserve(v.size() + 1);

yang tidak diperlukan karena jika vektor keluar dari ukurannya, itu akan berarti reserve.

Vektor bertanggung jawab atas hal ini, bukan Anda.

Keduanya aman karena push_back akan menyalin nilainya, bukan referensi. Jika Anda menyimpan pointer, itu masih aman sejauh menyangkut vektor, tetapi ketahuilah bahwa Anda akan memiliki dua elemen vektor yang menunjuk ke data yang sama.

Bagian 23.2.1 Persyaratan Wadah Umum

16

• a.push_back (t) Menambahkan salinan t. Membutuhkan: T akan menjadi CopyInsertable ke X.
• a.push_back (rv) Menambahkan salinan rv. Membutuhkan: T akan menjadi MoveInsertable ke X.

Implementasi push_back karena itu harus memastikan bahwa salinan v[0] dimasukkan. Dengan contoh balasan, dengan asumsi implementasi yang akan dialokasikan kembali sebelum menyalin, itu tidak akan dengan pasti menambahkan salinan v[0]dan dengan demikian melanggar spesifikasi.

Dari 23.3.6.5/1: Causes reallocation if the new size is greater than the old capacity. If no reallocation happens, all the iterators and references before the insertion point remain valid.

Karena kami menyisipkan di akhir, tidak ada referensi yang akan dibatalkan jika vektor tidak diubah ukurannya. Jadi jika vektor capacity() > size()maka dijamin akan berfungsi, jika tidak dijamin tidak akan terdefinisi.