Std :: reference_wrapper ile basit işaretçi arasındaki fark nedir?

Neden sahip olmaya ihtiyaç var std::reference_wrapper? Nerelerde kullanılmalı? Basit bir işaretçiden farkı nedir? Performansı basit bir işaretçiye kıyasla nasıl?

std::reference_wrapperşablonlarla birlikte kullanışlıdır. Bir nesneyi üzerine bir işaretçi depolayarak sararak, olağan semantiğini taklit ederken yeniden atama ve kopyalamaya izin verir. Ayrıca, belirli kütüphane şablonlarına nesneler yerine referansları saklamalarını söyler.

STL'deki functor'ları kopyalayan algoritmaları düşünün: Functor'un kendisi yerine functor'a atıfta bulunan bir referans sarmalayıcıyı ileterek bu kopyayı önleyebilirsiniz:

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

Bu işe yarıyor çünkü…

• ... reference_wrappers aşırı yükoperator() onlar sadece işlev gibi çağrılabilir yüzden bakın nesneleri:

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

• … (Un) sıradan referanslar gibi, kopyalama (ve atama) reference_wrapperssadece pointee atar.

  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>
  

Bir referans sarmalayıcının kopyalanması pratik olarak bir işaretçiyi kopyalamaya eşdeğerdir, bu da olabildiğince ucuzdur. Kullanmanın doğasında olan tüm işlev çağrıları (örneğin, yapılacak olanlar operator()) tek satırlık olduklarından sadece satır içi olmalıdır.

reference_wrappere-postalar std::refvestd::cref aracılığıyla oluşturulur :

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>

Şablon argümanı, başvurulan nesnenin türünü ve cv niteliğini belirtir; r2a anlamına gelir const intve yalnızca bir referans verir const int. constİçlerinde functor olan sarmalayıcılara başvurmak için yapılan çağrılar yalnızca constüye işlev operator()lerini çağırır .

Rvalue başlatıcılarına izin verilmesi yarardan çok zarar vereceğinden izin verilmez. R değerleri yine de taşınacağı için (ve kısmen kaçınılsa bile garantili kopya eleme ile ), anlambilimini geliştirmiyoruz; bir referans sarmalayıcı pointee'in ömrünü uzatmadığından, sarkan işaretçiler ekleyebiliriz.

Kütüphane etkileşimi

Daha önce bahsedildiği gibi , karşılık gelen argümanı a'dan geçirerek make_tuplesonuçta bir referansın saklanması talimatı verilebilir :tuplereference_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&>

Bunun forward_as_tupleşunlardan biraz farklı olduğuna dikkat edin : Burada, bağımsız değişken olarak r değerlerine izin verilmez.

std::bindaynı davranışı gösterir: Bağımsız değişkeni kopyalamaz, ancak bir reference_wrapper. Bu bağımsız değişkenin (veya bindfunctorun !) Kopyalanması gerekmiyorsa ancak -functor kullanılırken kapsam dahilinde kalırsa kullanışlıdır.

Sıradan işaretçilerden farkı

• Ek bir sözdizimsel yönlendirme seviyesi yoktur. İşaretçilerin başvurdukları nesnenin bir değerini elde etmek için referanslarının kaldırılması gerekir; reference_wrappers örtük bir dönüştürme operatörüne sahiptir ve sardıkları nesne gibi çağrılabilir.

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

• reference_wrappers, işaretçilerden farklı olarak, boş bir duruma sahip değildir. Bir referansla veya başka biriylereference_wrapper başlatılmaları gerekir .

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

• Bir benzerlik, yüzeysel kopya semantiğidir: İşaretçiler ve reference_wrapperler yeniden atanabilir.

En az iki motive edici amaç vardır std::reference_wrapper<T>:

1. Fonksiyon şablonlarına değer parametresi olarak aktarılan nesnelere referans semantiği vermektir. Örneğin, std::for_each()işlev nesnesi parametresini değerine göre alan, geçmek istediğiniz büyük bir işlev nesnesine sahip olabilirsiniz . Nesneyi kopyalamaktan kaçınmak için kullanabilirsiniz

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

   Bağımsız değişkenleri std::reference_wrapper<T>bir std::bind()ifadeye göre geçirmek, argümanları değere göre değil, başvuruya göre bağlamak için oldukça yaygındır.

2. Bir kullanırken std::reference_wrapper<T>ile std::make_tuple()ilgili kayıt düzeni elemanının bir hale T&yerine daha T:

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

Kendi kendini belgeleyen kod açısından diğer bir fark, bir reference_wrappernesnenin sahipliğini esasen reddetmesidir. Bunun aksine, bir unique_ptrsahiplik iddia ederken, çıplak bir işaretçi sahip olabilir veya olmayabilir (çok sayıda ilgili koda bakmadan bilmek mümkün değildir):

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

Bunu, referansların etrafını saran kullanışlı bir paket olarak düşünebilirsiniz, böylece bunları kaplarda kullanabilirsiniz.

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

Temelde bir CopyAssignablesürümü T&. Bir referans istediğinizde, ancak atanabilir, kullanılabilir std::reference_wrapper<T>veya yardımcı işlevi olması gerekir std::ref(). Veya bir işaretçi kullanın.

Diğer tuhaflıklar 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

Ve karşılaştırma:

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

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