Sự khác biệt giữa std :: reference_wrapper và con trỏ đơn giản?

Tại sao cần phải có std::reference_wrapper? Nó nên được sử dụng ở đâu? Nó khác với một con trỏ đơn giản như thế nào? Hiệu suất của nó như thế nào so với một con trỏ đơn giản?

std::reference_wrapperhữu ích khi kết hợp với các mẫu. Nó bao bọc một đối tượng bằng cách lưu trữ một con trỏ tới nó, cho phép gán lại và sao chép trong khi bắt chước ngữ nghĩa thông thường của nó. Nó cũng hướng dẫn các mẫu thư viện nhất định để lưu trữ các tham chiếu thay vì các đối tượng.

Hãy xem xét các thuật toán trong STL sao chép bộ chức năng: Bạn có thể tránh sao chép đó bằng cách chỉ cần chuyển một trình bao bọc tham chiếu tham chiếu đến bộ chức năng thay vì chính bộ chức năng:

unsigned arr[10];
std::mt19937 myEngine;
std::generate_n( arr, 10, std::ref(myEngine) ); // Modifies myEngine's state

Điều này hoạt động vì…

• ... reference_wrappers quá tảioperator() vì vậy họ có thể được gọi giống như chức năng các đối tượng họ đề cập đến:

  std::ref(myEngine)() // Valid expression, modifies myEngines state

• … (Un) giống như các tham chiếu thông thường, sao chép (và gán) reference_wrapperschỉ chỉ định người được chỉ định.

  int i, j;
  auto r = std::ref(i); // r refers to i
  r = std::ref(j); // Okay; r refers to j
  r = std::cref(j); // Error: Cannot bind reference_wrapper<int> to <const int>
  

Việc sao chép một trình bao bọc tham chiếu thực tế tương đương với việc sao chép một con trỏ, nó rẻ như cho. Tất cả các lệnh gọi hàm vốn có trong việc sử dụng nó (ví dụ: các lệnh gọi đến operator()) chỉ nên được nội dòng vì chúng là một chữ lót.

reference_wrappers được tạo qua std::refvàstd::cref :

int i;
auto r = std::ref(i); // r is of type std::reference_wrapper<int>
auto r2 = std::cref(i); // r is of type std::reference_wrapper<const int>

Đối số mẫu chỉ định loại và trình độ cv của đối tượng được tham chiếu đến; r2đề cập đến một const intvà sẽ chỉ mang lại một tham chiếu đến const int. Các lệnh gọi đến các trình bao bọc tham chiếu với các chức năng consttrong đó sẽ chỉ gọi consthàm thành viên operator()s.

Các trình khởi tạo Rvalue không được phép, vì cho phép chúng sẽ gây hại nhiều hơn lợi. Vì các giá trị sẽ được di chuyển bằng mọi cách (và với việc tách bản sao được đảm bảo ngay cả khi điều đó được tránh một phần), chúng tôi không cải thiện ngữ nghĩa; chúng ta có thể giới thiệu các con trỏ treo lơ lửng, vì một trình bao bọc tham chiếu không kéo dài thời gian tồn tại của con trỏ.

Thư viện tương tác

Như đã đề cập trước đây, người ta có thể hướng dẫn make_tuplelưu trữ một tham chiếu trong kết quả tuplebằng cách chuyển đối số tương ứng thông qua reference_wrapper:

int i;
auto t1 = std::make_tuple(i); // Copies i. Type of t1 is tuple<int>
auto t2 = std::make_tuple(std::ref(i)); // Saves a reference to i.
                                        // Type of t2 is tuple<int&>

Lưu ý rằng điều này hơi khác với forward_as_tuple: Ở đây, không cho phép các giá trị làm đối số.

std::bindhiển thị cùng một hành vi: Nó sẽ không sao chép đối số nhưng lưu trữ một tham chiếu nếu nó là một reference_wrapper. Hữu ích nếu đối số đó (hoặc functor!) Không cần được sao chép nhưng vẫn ở trong phạm vi trong khi bind-functor được sử dụng.

Sự khác biệt so với con trỏ thông thường

• Không có cấp độ bổ sung của hướng cú pháp. Con trỏ phải được tham chiếu để có được giá trị cho đối tượng mà chúng tham chiếu đến; reference_wrappers có một toán tử chuyển đổi ngầm định và có thể được gọi giống như đối tượng mà chúng bao bọc.

  int i;
  int& ref = std::ref(i); // Okay
  

• reference_wrappers, không giống như con trỏ, không có trạng thái null. Chúng phải được khởi tạo bằng tham chiếu hoặc tham chiếu khácreference_wrapper .

  std::reference_wrapper<int> r; // Invalid

• Một điểm tương đồng là ngữ nghĩa sao chép nông: Các con trỏ và reference_wrappers có thể được gán lại.

Có ít nhất hai mục đích thúc đẩy std::reference_wrapper<T>:

1. Nó là để cung cấp ngữ nghĩa tham chiếu cho các đối tượng được truyền dưới dạng tham số giá trị cho các mẫu hàm. Ví dụ: bạn có thể có một đối tượng hàm lớn mà bạn muốn chuyển đến std::for_each(), đối tượng này nhận tham số đối tượng hàm theo giá trị. Để tránh sao chép đối tượng, bạn có thể sử dụng

   std::for_each(begin, end, std::ref(fun));

   Việc truyền các đối số std::reference_wrapper<T>cho một std::bind()biểu thức là khá phổ biến để ràng buộc các đối số bằng tham chiếu thay vì theo giá trị.

2. Khi sử dụng một std::reference_wrapper<T>với std::make_tuple()phần tử tuple tương ứng sẽ trở thành một T&thay vì một T:

   T object;
   f(std::make_tuple(1, std::ref(object)));
   

Một sự khác biệt khác, về mã tự lập tài liệu, đó là việc sử dụng reference_wrappervề cơ bản từ chối quyền sở hữu đối tượng. Ngược lại, một unique_ptrxác nhận quyền sở hữu, trong khi một con trỏ trần có thể có hoặc có thể không được sở hữu (không thể biết nếu không xem nhiều mã liên quan):

vector<int*> a;                    // the int values might or might not be owned
vector<unique_ptr<int>> b;         // the int values are definitely owned
vector<reference_wrapper<int>> c;  // the int values are definitely not owned

Bạn có thể coi nó như một trình bao bọc tiện lợi xung quanh các tham chiếu để bạn có thể sử dụng chúng trong các vùng chứa.

std::vector<std::reference_wrapper<T>> vec; // OK - does what you want
std::vector<T&> vec2; // Nope! Will not compile

Về cơ bản nó là một CopyAssignablephiên bản của T&. Bất cứ lúc nào bạn muốn một tham chiếu, nhưng nó phải được gán, sử dụng std::reference_wrapper<T>hoặc chức năng trợ giúp của nó std::ref(). Hoặc sử dụng một con trỏ.

Những điều kỳ quặc khác sizeof::

sizeof(std::reference_wrapper<T>) == sizeof(T*) // so 8 on a 64-bit box
sizeof(T&) == sizeof(T) // so, e.g., sizeof(vector<int>&) == 24

Và so sánh:

int i = 42;
assert(std::ref(i) == std::ref(i)); // ok

std::string s = "hello";
assert(std::ref(s) == std::ref(s)); // compile error