Aynı vektörden bir öğeyi geri itmek güvenli midir?

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

İkinci geri itme bir yeniden atamaya neden olursa, vektördeki ilk tam sayıya yapılan başvuru artık geçerli olmayacaktır. Yani bu güvenli değil mi?

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

Bu onu güvenli kılıyor mu?

Standartta olası bir kusur olarak http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526 bu sorunu (veya ona çok benzer bir şeyi) ele almış gibi görünüyor :

1) const referansı ile alınan parametreler, işlevin yürütülmesi sırasında değiştirilebilir.

Örnekler:

Verilen std :: vektör v:

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

v [2], vektörün elemanları hareket ettirilerek değiştirilebilir

Önerilen çözüm, bunun bir kusur olmadığıydı:

vector :: insert (iter, value) çalışması için gereklidir, çünkü standart çalışmaması için izin vermez.

Evet, güvenlidir ve standart kitaplık uygulamaları bunu yapmak için çemberlerden geçer.

Uygulayıcıların bu gereksinimi bir şekilde 23.2 / 11'e kadar izlediğine inanıyorum, ancak nasıl olduğunu anlayamıyorum ve daha somut bir şey de bulamıyorum. Bulabildiğim en iyi şey şu makale:

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

Libc ++ 'ın ve libstdc ++' nın uygulamalarının incelenmesi, bunların da güvenli olduğunu gösterir.

Standart, ilk örneğinizin bile güvenli olmasını garanti eder. C ++ 11'den alıntı yapma

[Sequence.reqmts]

3 Tablo 100 ve 101'de ... Xbir sıra kapsayıcı sınıfını abelirtir X, türdeki öğeleri içeren bir değeri belirtir T, ... tbir ldeğer veya sabit değerX::value_type

16 Tablo 101 ...

İfade a.push_back(t) dönüş türü void Operasyonel semantik bir kopyasını ekler t. gerektirir: T olacaktır CopyInsertableiçine X. Konteyner basic_string , deque, list,vector

Dolayısıyla, tam olarak önemsiz olmasa da, uygulama push_back,.

İlk örneğin güvenli olduğu açık değildir, çünkü bunun en basit uygulaması push_back, gerekirse önce vektörü yeniden tahsis etmek ve ardından referansı kopyalamak olacaktır.

Ama en azından Visual Studio 2010 ile güvenli görünüyor. Bunun uygulanması push_back, vektördeki bir öğeyi geri ittiğinizde durumun özel olarak ele alınmasını sağlar. Kod aşağıdaki şekilde yapılandırılmıştır:

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

Bu standarttan bir garanti değildir, ancak başka bir veri noktası olarak LLVM libc ++v.push_back(v[0]) için güvenlidir .

libc ++ 'ınstd::vector::push_back__push_back_slow_path belleği yeniden tahsis etmesi gerektiğinde çağırır :

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

İlk sürüm kesinlikle güvenli DEĞİLDİR:

Standart bir kütüphane kabı veya dizi üyesi işlevi çağrılarak elde edilen yineleyiciler üzerindeki işlemler, temeldeki kaba erişebilir ancak onu değiştiremez. [Not: Özellikle yineleyicileri geçersiz kılan kapsayıcı işlemleri, bu kapsayıcıyla ilişkili yineleyiciler üzerindeki işlemlerle çakışır. - son not]

bölüm 17.6.5.9'dan

Bunun, insanların normalde iş parçacığı ile birlikte düşündükleri veri yarışları ile ilgili bölüm olduğuna dikkat edin ... ancak gerçek tanım "önce olur" ilişkileri içerir ve içeriğin çoklu yan etkileri arasında herhangi bir sıralama ilişkisi görmüyorum push_back. burada oynayın, yani referans geçersiz kılma, yeni kuyruk elemanının kopyalanması ile ilgili olarak sıralı olarak tanımlanmıyor gibi görünüyor.

Tamamen güvenlidir.

İkinci örneğinizde

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

bu gerekli değildir çünkü vektör boyutunun dışına çıkarsa reserve,.

Bu şeylerden Vector sorumlu, sen değil.

Push_back referansı değil değeri kopyalayacağından her ikisi de güvenlidir. İşaretçileri depoluyorsanız, vektör söz konusu olduğunda bu hala güvenlidir, ancak sadece vektörünüzün aynı verilere işaret eden iki elemanına sahip olacağınızı bilin.

Bölüm 23.2.1 Genel Konteyner Gereksinimleri

16

• a.push_back (t) t'nin bir kopyasını ekler. Gerektirir: T, X'e CopyInsertable olacaktır.
• a.push_back (rv) rv'nin bir kopyasını ekler. Gerektirir: T, X'e MoveInsertable olacaktır.

Bu nedenle push_back uygulamaları, bir kopyasının v[0] eklendiğinden emin olmalıdır . Karşı örnek olarak, kopyalamadan önce yeniden tahsis edecek bir uygulamayı varsayarsak, kesinlikle bir kopyasını eklemeyecektir v[0]ve bu nedenle özellikleri ihlal eder.

23.3.6.5 / 1'den: 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.

Sonunda eklediğimiz için , vektör yeniden boyutlandırılmazsa hiçbir referans geçersiz olmayacaktır . Yani vektörün capacity() > size()çalışması garanti edilir, aksi takdirde tanımsız davranış olacağı garanti edilir.