Difference between std::reference_wrapper and simple pointer?
Solution 1
std::reference_wrapper
is useful in combination with templates. It wraps an object by storing a pointer to it, allowing for reassignment and copy while mimicking its usual semantics. It also instructs certain library templates to store references instead of objects.
Consider the algorithms in the STL which copy functors: You can avoid that copy by simply passing a reference wrapper referring to the functor instead of the functor itself:
unsigned arr[10];
std::mt19937 myEngine;
std::generate_n( arr, 10, std::ref(myEngine) ); // Modifies myEngine's state
This works because…
-
…
reference_wrapper
s overloadoperator()
so they can be called just like the function objects they refer to:std::ref(myEngine)() // Valid expression, modifies myEngines state
-
…(un)like ordinary references, copying (and assigning)
reference_wrappers
just assigns the pointee.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>
Copying a reference wrapper is practically equivalent to copying a pointer, which is as cheap as it gets. All the function calls inherent in using it (e.g. the ones to operator()
) should be just inlined as they are one-liners.
reference_wrapper
s are created via std::ref
and 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>
The template argument specifies the type and cv-qualification of the object referred to; r2
refers to a const int
and will only yield a reference to const int
. Calls to reference wrappers with const
functors in them will only call const
member function operator()
s.
Rvalue initializers are disallowed, as permitting them would do more harm than good. Since rvalues would be moved anyway (and with guaranteed copy elision even that's avoided partly), we don't improve the semantics; we can introduce dangling pointers though, as a reference wrapper does not extend the pointee's lifetime.
Library interaction
As mentioned before, one can instruct make_tuple
to store a reference in the resulting tuple
by passing the corresponding argument through a 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&>
Note that this slightly differs from forward_as_tuple
: Here, rvalues as arguments are not allowed.
std::bind
shows the same behavior: It won't copy the argument but store a reference if it is a reference_wrapper
. Useful if that argument (or the functor!) need not be copied but stays in scope while the bind
-functor is used.
Difference from ordinary pointers
-
There is no additional level of syntactical indirection. Pointers have to be dereferenced to obtain an lvalue to the object they refer to;
reference_wrapper
s have an implicit conversion operator and can be called like the object they wrap.int i; int& ref = std::ref(i); // Okay
-
reference_wrapper
s, unlike pointers, don't have a null state. They have to be initialized with either a reference or anotherreference_wrapper
.std::reference_wrapper<int> r; // Invalid
A similarity are the shallow copy semantics: Pointers and
reference_wrapper
s can be reassigned.
Solution 2
There are, at least, two motivating purposes of std::reference_wrapper<T>
:
-
It is to give reference semantics to objects passed as value parameter to function templates. For example, you may have a large function object you want to pass to
std::for_each()
which takes its function object parameter by value. To avoid copying the object, you can usestd::for_each(begin, end, std::ref(fun));
Passing arguments as
std::reference_wrapper<T>
to anstd::bind()
expression is quite common to bind arguments by reference rather than by value. -
When using an
std::reference_wrapper<T>
withstd::make_tuple()
the corresponding tuple element becomes aT&
rather than aT
:T object; f(std::make_tuple(1, std::ref(object)));
Solution 3
Another difference, in terms of self-documenting code, is that using a reference_wrapper
essentially disavows ownership of the object. In contrast, a unique_ptr
asserts ownership, while a bare pointer might or might not be owned (it's not possible to know without looking at lots of related code):
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
Solution 4
You can think of it as a convenience wrapper around references so that you can use them in containers.
std::vector<std::reference_wrapper<T>> vec; // OK - does what you want
std::vector<T&> vec2; // Nope! Will not compile
It's basically a CopyAssignable
version of T&
. Any time you want a reference, but it has to be assignable, use std::reference_wrapper<T>
or its helper function std::ref()
. Or use a pointer.
Other quirks: 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
And comparison:
int i = 42;
assert(std::ref(i) == std::ref(i)); // ok
std::string s = "hello";
assert(std::ref(s) == std::ref(s)); // compile error
Laurynas Lazauskas
Updated on October 17, 2020Comments
-
Laurynas Lazauskas over 3 years
Why is there a need to have
std::reference_wrapper
? Where should it be used? How is it different from a simple pointer? How its performance compares to a simple pointer? -
user1708860 over 9 yearsCan you please give a code example for the first case?
-
Dietmar Kühl over 9 years@user1708860: you mean other than the one given...?
-
user1708860 over 9 yearsI mean actual code that goes with the std::ref(fun) because i don't understand how is used (unless fun is an object and not a function...)
-
Dietmar Kühl over 9 years@user1708860: yes, most likely
fun
is a function object (i.e. an object of a class with a function call operator) and not a function: iffun
happens to be an actual function,std::ref(fun)
have no purpose and make the code potentially slower. -
Laurynas Lazauskas over 9 yearsWhy would one use
std::vector<std::reference_wrapper<T>> vec;
instead ofstd::vector<T*> vec;
? -
Laurynas Lazauskas over 9 yearsIs
std::make_tuple(std::ref(i));
superior tostd::make_tuple(&i);
in some way? -
Columbo over 9 years@LaurynasLazauskas It's different. The latter you showed saves a pointer to
i
, not a reference to it. -
Columbo over 9 years@LaurynasLazauskas One could call function objects contained in the wrapper directly. That is also explained in my answer.
-
Laurynas Lazauskas over 9 yearsHm... I guess I still can't distinct these two as well as I would like... Well, thank you.
-
Riga over 9 yearsSince reference implementation is just a pointer inside I can not understand why wrappers add any indirection or performance penalty
-
Riga over 9 yearsIt should be no more indirection than a simple reference when it comes to a release code
-
anatolyg over 9 years@Columbo How is an array of reference wrappers possible if they don't have null state? Don't arrays usually start with all elements set to null state?
-
Columbo over 9 years@anatolyg What hinders you from initializing that array?
-
David Stone over 9 yearsI would expect the compiler to inline the trivial
reference_wrapper
code, making it identical to code that uses a pointer or reference. -
David Stone over 9 years@LaurynasLazauskas:
std::reference_wrapper
has the guarantee that the object is never null. Consider a class memberstd::vector<T *>
. You have to examine all of the class code to see if this object can ever store anullptr
in the vector, whereas withstd::reference_wrapper<T>
, you are guaranteed to have valid objects. -
Bwmat over 7 yearsunless it's pre-c++11 code, the first example should imply optional, unowned values, for example for a cache lookup based on index. It would be nice if std provided us with something standard to represent a non-null, owned value (unique & shared variants)
-
Rufus over 7 yearsPointers can also be declared such to not have a null state with not_null
-
Columbo over 7 years@Woofas That makes no difference. If I take a parameter that is a pointer, I don't know whether it was initialized using
not_null
. -
Rufus over 7 years@Columbo It's possible to specify a parameter as
not_null
such that passing a null pointer to it becomes invalid -
Columbo over 7 years@Woofas Oh, sorry, I thought that was a function (I'm used to UpperCamelCase for class names). Sure, you could.
-
underscore_d about 7 years@Woofas Interesting, but I don't know why we would use a pointer in that case, and not just a reference. Did they ever explain why
not_null
is preferable? I don't see it, but I'm not known for being very imaginative... -
underscore_d almost 6 yearsI fail to see how your "quirks" are quirks. Both are by definition: (1) A
reference_wrapper
must refer to its object via a pointer (because it must be assignable, otherwise we wouldn't need this class, etc.), and that's all it needs. (2) A real reference has nosizeof
according to the language, so the operator always returns thesizeof
the referred type (the fact that a reference within an object is implemented as a pointer and evident in thesizeof
said object is an implementation detail). -
Barry almost 6 years@underscore_d I fail to see how something being true by definition somehow prevents it from being a quirk. Given a
vector<int> v;
,std::vector x{v, v}
andstd::vector y{v}
have different types. That's true by definition. But also a quirk of CTAD rules. -
dteod almost 5 years
reference_wrappers, unlike pointers, don't have a null state. They have to be initialized with either a reference or another reference_wrapper.
Since C++17 you can use astd::optional
to have a reference without initialization:std::optional<std::reference_wrapper<int>> x; auto y = 4; x = y;
Accessing to it is a bit verbose though:std::cout << x.value().get();
-
Columbo almost 5 yearsI think
optional<int&>
is better? -
bjaastad_e about 4 yearsIt's maybe not as important in C++11, where bare pointers will nearly always be borrowed values anyway.
-
underscore_d almost 4 years
reference_wrapper
is superior to raw pointers not only because it is clear that it is non-owning, but also because it cannot benullptr
(without shenanigans) and thus users know they can't passnullptr
(without shenanigans) and you know you don't have to check for it. -
Spyros Mourelatos almost 3 years@underscore_d What do you mean "without shenanigans"? Is it possible with shenanigans? I am very curious
-
underscore_d almost 3 years@SpyrosMourelatos It is possible, albeit with undefined behaviour and hence totally inadvisable... to form a 'null reference'. One can then shove the resulting invalid reference into a
reference_wrapper
. But creating/using such references have undefined behaviour, hence my - overly generous! - labelling of it as "shenanigans". See Is null reference possible? -
Spyros Mourelatos almost 3 years@underscore_d Thank you very much , with your help I can finally force my colleagues at work to commit suicide. :P
-
Johann Gerell almost 3 years@Columbo: "[...] a program is ill-formed if it instantiates an optional with a reference type" en.cppreference.com/w/cpp/utility/optional
-
Jeff Garrett over 2 years@Bwmat non-null unique ownership is currently not possible in the language in a reasonable way.