Tại sao không C++ std :: map :: operator [] sử dụng tại chỗ mới?

Question

Nếu bạn sử dụng C++ std :: map (và các vùng chứa khác) với các kiểu giá trị, bạn sẽ nhận thấy rằng chèn vào bản đồ gọi hàm hủy cho kiểu phần tử của bạn. Điều này là do việc thực hiện các operator [] là yêu cầu của C++ spec để được tương đương này:

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

Nó kêu gọi các nhà xây dựng mặc định của loại hình của bạn để xây dựng cặp đó. Giá trị tạm thời đó sau đó được sao chép vào bản đồ và sau đó bị hủy. Xác nhận điều này có thể được tìm thấy trong this stackoverflow post và here on codeguru.

Điều tôi thấy lạ là điều này có thể được triển khai mà không cần biến tạm thời và vẫn tương đương. Có một tính năng của C++ được gọi là "inplace new". Bản đồ :: std và các vùng chứa khác có thể phân bổ không gian trống cho đối tượng để sống và sau đó gọi rõ ràng hàm tạo mặc định của phần tử trên không gian được phân bổ.

Câu hỏi của tôi: Tại sao không có triển khai std :: bản đồ mà tôi đã thấy sử dụng tại chỗ mới để tối ưu hóa hoạt động này? Dường như với tôi rằng nó sẽ cải thiện đáng kể hiệu suất của hoạt động cấp thấp này. Nhưng nhiều con mắt đã nghiên cứu cơ sở mã STL, vì vậy tôi con số đó phải có một số lý do nó được thực hiện theo cách này.

Answer 1

Nói chung, bạn chỉ định hoạt động cấp cao hơn như [] về mặt cấp độ thấp hơn là một ý tưởng hay.

Trước C++ 11, làm như vậy với [] sẽ rất khó mà không cần sử dụng insert.

Trong C++ 11, việc thêm std::map<?>::emplace và các nội dung tương tự cho std::pair cho chúng tôi khả năng tránh sự cố đó. Nếu bạn định nghĩa lại nó để sử dụng như vậy tại chỗ xây dựng, thêm (hy vọng elided) đối tượng sáng tạo sẽ biến mất.

Tôi không thể nghĩ ra lý do nào không làm điều này. Tôi sẽ khuyến khích bạn đề xuất nó để chuẩn hóa.

Để chứng minh bản sao-less chèn vào một std::map, chúng ta có thể làm như sau:

#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 - như bạn có thể nhìn thấy, không có tạm thời được tạo ra.

Vì vậy, nếu chúng ta thay thế

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

với

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

không tạm thời sẽ được tạo ra (khoảng trắng thêm để tôi có thể theo dõi các () s).

Answer 2

Trước hết, operator[<key>] cho std::map chỉ tương đương với thao tác chèn nếu yêu cầu <key> không được tìm thấy. Trong trường hợp này, chỉ một tham chiếu đến khóa là cần thiết và chỉ một tham chiếu đến giá trị được lưu trữ được tạo ra.

Thứ hai, khi phần tử mới được chèn vào, không có cách nào để biết liệu thao tác sao chép có theo sau hay không. Bạn có thể có map[_k] = _v; hoặc bạn có thể có _v = map[_k];.Sau đó, khóa học có cùng các yêu cầu như bên ngoài nhiệm vụ, tức là map[_k].method_call();, nhưng không không sử dụng hàm tạo bản sao (không có nguồn để xây dựng từ). Về chèn, tất cả các bên trên yêu cầu hàm tạo mặc định của số value_type được gọi và không gian đó được phân bổ cho nó. Ngay cả khi chúng ta có thể biết khi viết operator[] mà chúng tôi đã sử dụng trong trường hợp chuyển nhượng, chúng tôi không thể sử dụng "inplace new" vì thứ tự các hoạt động. Các nhà xây dựng value_type sẽ phải được gọi là đầu tiên, theo sau là value_type::operator=, mà đòi hỏi sự kêu gọi của các nhà xây dựng bản sao.

Suy nghĩ hay.