Neden C++ std :: map :: operator [] inplace yeni kullanıyor?

Question

Eğer değer türleri ile C++ std :: harita (ve diğer kapları) kullanıyorsanız, harita içine yerleştirirken sizin öğe türü için yıkıcı çağırır göreceksiniz. O çiftini oluşturmak için türünüze varsayılan kurucuyu çağıran

(*((std::map<>::insert(std::make_pair(x, T()))).first)).second 

: operatör uygulanması [] Buna eşdeğer olmak C++ Spec gerektirdiği olmasıdır. Bu geçici değer daha sonra haritaya kopyalanır ve sonra imha edilir. Bu teyidi this stackoverflow post ve here on codeguru bulunabilir.

Ne garip buluyorum bu eşdeğer hala geçici değişken için gerek kalmadan uygulanabilir ve olabilir olmasıdır. C++ özelliği "inplace new" olarak adlandırılmıştır. Std :: map ve diğer kapsayıcılar, nesnenin yaşaması için boş alan tahsis edebilir ve daha sonra ayrılan alanda öğenin varsayılan yapıcısını açıkça çağırır.

Soruma Soru: Neden std :: map uygulamalarının hiçbiri, bu işlemi en iyi duruma getirmek için inplace yeni kullanımının hiçbiri yapmıyor? Bana öyle geliyor ki, bu düşük seviyedeki operasyonun performansını önemli ölçüde artıracaktır. Ancak pek çok göz STL kod tabanını çalışmış, bu yüzden bu şekilde yapılmasının bir sebebi olmalı diye düşünüyorum.

Answer 1

Genel olarak, alt düzey olanlar açısından [] gibi yüksek bir seviyede işlemini belirten iyi bir fikirdir.

C++ 11'den önce [] ile bunu yapmak insert kullanmadan zor olabilir. C

11 ++, std::pair için std::map<?>::emplace eklenmesi ve benzeri şeyler bize bu sorunu önlemek olanağı verir. Eğer bunu yeniden tanımladıysanız, böyle bir yerinde yapı kullanacak olursanız, ekstra (umaruzca elenmiş) nesne yaratır.

ben bunu bir sebep düşünemiyorum. Standardizasyon için teklif etmenizi öneririm.

biz aşağıdakileri yapabilirsiniz, bir std::map içine kopyalamaya karşı daha az ekleme göstermek için:

#include <map> 
#include <iostream> 

struct no_copy_type { 
    no_copy_type(no_copy_type const&)=delete; 
    no_copy_type(double) {} 
    ~no_copy_type() { std::cout << "destroyed\n"; } 
}; 
int main() { 
    std::map< int, no_copy_type > m; 
    m.emplace(
    std::piecewise_construct, 
    std::forward_as_tuple(1), 
    std::forward_as_tuple(3.14) 
); 
    std::cout << "destroy happens next:\n"; 
} 

live example - Gördüğünüz gibi, hiçbir geçici oluşturulur.

yüzden

(* 
    (
    (
     std::map<>::emplace(
     std::piecewise_construct, 
     std::forward_as_tuple(std::forward<X>(x)), 
     std::forward_as_tuple() 
    ) 
).first 
).second 

ile

(*((std::map<>::insert(std::make_pair(x, T()))).first)).second 

değiştirirseniz hiçbir geçici yaratılmış olacaktır (boşluk ı () s takip böylece eklendi).

Answer 2

Öncelikle, std::map için operator[<key>] talep <key> bulunamazsa eğer bir ekleme işlemi sadece eşdeğerdir. Bu durumda, sadece bir referansa ihtiyaç duyulur ve üretilen depolanmış değere sadece bir referans gerekir.

İkincisi, yeni öğe eklendiğinde, bir kopyalama işleminin yapılıp yapılmayacağını bilmenin bir yolu yoktur. Sen map[_k] = _v; sahip olabilir veya _v = map[_k]; olabilir.Sonuncusu, bir ödevin dışında, yani map[_k].method_call();'da olduğu gibi aynı gerekliliklere sahiptir, fakat 10 ()'un kopya yapıcısını kullanmamaktadır (bu, yapılandırılacak bir kaynak değildir). Ekleme ile ilgili olarak, yukarıdakilerin tümü, value_type varsayılan kurucusunun çağrılmasını ve bu alanın bunun için tahsis edilmesini gerektirir. Atama kullanımında olduğumuz için operator[] yazarken bile bilsek bile, operasyon sırasından dolayı “inplace new” i kullanamadık. İlk olarak value_type yapıcısının çağrılması gerekiyordu, ardından kopya kurucusunun çağrılmasını gerektiren value_type::operator=. Yine de düşünmek güzeldir.