std::reference_wrapper

Defined in header `<functional>`
template< class T > class reference_wrapper;		(since C++11)

std::reference_wrapper is a class template that wraps a reference in a copyable, assignable object. It is frequently used as a mechanism to store references inside standard containers (like std::vector or std::pair) which can not normally hold references.

Specifically, std::reference_wrapper is a CopyConstructible and CopyAssignable wrapper around a reference to object or reference to function of type T. Instances of std::reference_wrapper are objects (they can be copied or stored in containers) but they are implicitly convertible to T&, so that they can be used as arguments with the functions that take the underlying type by reference.

Helper functions std::ref and std::cref are often used to generate std::reference_wrapper objects.

std::reference_wrapper is also used to pass objects to std::bind or to the constructor of std::thread by reference.

type	definition
`type`	`T`
`result_type`	The return type of `T` if `T` is a function. Otherwise, not defined
`argument_type`	1) if `T` is a function or pointer to function that takes one argument of type `A1`, then `argument_type` is `A1`. 2) if `T` is a pointer to member function of class `T0` that takes no arguments, then `argument_type` is `T0*`, possibly cv-qualified 3) if `T` is a class type with a member type `T::argument_type`, then `argument_type` is an alias of that
`first_argument_type`	1) if `T` is a function or pointer to function that takes two arguments of type s `A1` and `A2`, then `first_argument_type` is `A1`. 2) if `T` is a pointer to member function of class `T0` that takes one argument, then `first_argument_type` is `T0*`, possibly cv-qualified 3) if `T` is a class type with a member type `T::first_argument_type`, then `first_argument_type` is an alias of that
`second_argument_type`	1) if `T` is a function or pointer to function that takes two arguments of type s `A1` and `A2`, then `second_argument_type` is `A2`. 2) if `T` is a pointer to member function of class `T0` that takes one argument `A1`, then `second_argument_type` is `A1`, possibly cv-qualified 3) if `T` is a class type with a member type `T::second_argument_type`, then `second_argument_type` is an alias of that

[edit] Member functions

(constructor)	stores a reference in a new std::reference_wrapper object (public member function)
operator=	rebinds a std::reference_wrapper (public member function)
getoperator T&	accesses the stored reference (public member function)
operator()	calls the stored function (public member function)

[edit] Example

Demonstrates the use of reference_wrapper as a container of references, which makes it possible to access the same container using multiple indexes

Run this code

#include <algorithm>
#include <list>
#include <vector>
#include <iostream>
#include <functional>
 
int main()
{
    std::list<int> l = {-4, -3, -2, -1, 0, 1, 2, 3, 4};
 
    std::vector<std::reference_wrapper<int>> v(l.begin(), l.end());
    std::random_shuffle(v.begin(), v.end());
 
    std::cout << "Contents of the list: ";
    for (int n : l) {
        std::cout << n << ' ';
    }
    std::cout << '\n';
 
    std::cout << "Contents of the list, shuffled: ";
    for (int i : v) {
        std::cout << i << ' ';
    }
    std::cout << '\n';
 
    std::cout << "Doubling the values in the initial list...\n";
    for (int &i : l) {
        i *= 2;
    }
 
    std::cout << "Shuffled vector actually contains references: ";
    for (int i : v) {
        std::cout << i << ' ';
    }
    std::cout << '\n';
}

Output:

Contents of the list: -4 -3 -2 -1 0 1 2 3 4 
Contents of the list, shuffled: 0 -1 3 4 -4 1 -2 -3 2 
Doubling the values in the initial list...
Shuffled vector actually contains references: 0 -2 6 8 -8 2 -4 -6 4

[edit] See also

refcref (C++11)(C++11)	creates a std::reference_wrapper with a type deduced from its argument (function template)
bind (C++11)	binds one or more arguments to a function object (function template)

Language
Standard library headers
Concepts
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
Relational operators
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Pairs and tuples
pair
tuple (C++11)
piecewise_construct_t (C++11)
piecewise_construct (C++11)
Swap, forward and move
swap
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
declval (C++11)

Member functions
reference_wrapper::reference_wrapper
reference_wrapper::operator=
reference_wrapper::getreference_wrapper::operator T&
reference_wrapper::operator()

std::reference_wrapper

Contents

[edit] Member types

[edit] Member functions

[edit] Example

[edit] See also