std::reference_wrapper

 

C++

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)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

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>=

optional, any and variant (C++17)

optional

any

variant

in_placein_place_typein_place_indexin_place_tin_place_type_tin_place_index_t

Pairs and tuples

pair

tuple (C++11)

apply (C++17)

make_from_tuple (C++17)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

Elementary string conversions

to_chars (C++17)

from_chars (C++17)

chars_format (C++17)

Type operations

declval (C++11)

as_const (C++17)

 

Function objects

Function wrappers function (C++11) mem_fn (C++11) bad_function_call (C++11) invoke (C++17)	Bind bind (C++11) is_bind_expression (C++11) is_placeholder (C++11) _1, _2, _3, ... (C++11)
Reference wrappers
reference_wrapper (C++11)
refcref (C++11)(C++11)
Operator wrappers
plus minus negate multiplies divides modulus logical_and logical_or logical_not	equal_to not_equal_to greater less greater_equal less_equal bit_and bit_or bit_xor bit_not (C++14)
Negators
not_fn not1 (deprecated) not2 (deprecated)	unary_negate (deprecated) binary_negate (deprecated)
Searchers
default_searcher (C++17)
boyer_moore_searcher (C++17)
boyer_moore_horspool_searcher (C++17)
Old binders and adaptors
unary_function (until C++17) binary_function (until C++17) ptr_fun (until C++17) pointer_to_unary_function (until C++17) pointer_to_binary_function (until C++17) mem_fun (until C++17) mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (until C++17)(until C++17)(until C++17)(until C++17)	binder1stbinder2nd (until C++17)(until C++17) bind1stbind2nd (until C++17)(until C++17) mem_fun_ref (until C++17) mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (until C++17)(until C++17)(until C++17)(until C++17)

 

std::reference_wrapper

Member functions

reference_wrapper::reference_wrapper

reference_wrapper::operator=

reference_wrapper::getreference_wrapper::operator T&

reference_wrapper::operator()

 

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) which cannot 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.

std::reference_wrapper is guaranteed to be TriviallyCopyable.

(since C++17)

Member types

type	definition
type	T
result_type(deprecated in C++17)	The return type of T if T is a function. Otherwise, not defined
argument_type(deprecated in C++17)	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(deprecated in C++17)	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(deprecated in C++17)	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

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)

Possible implementation

template <class T> class reference_wrapper { public: // types typedef T type;   // construct/copy/destroy reference_wrapper(T& ref) noexcept : _ptr(std::addressof(ref)) {} reference_wrapper(T&&) = delete; reference_wrapper(const reference_wrapper&) noexcept = default;   // assignment reference_wrapper& operator=(const reference_wrapper& x) noexcept = default;   // access operator T& () const noexcept { return *_ptr; } T& get() const noexcept { return *_ptr; }   template< class... ArgTypes > typename std::result_of<T&(ArgTypes&&...)>::type operator() ( ArgTypes&&... args ) const { return std::invoke(get(), std::forward<ArgTypes>(args)...); }   private: T* _ptr; };

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 <numeric>
#include <random>
#include <functional>
 
int main()
{
    std::list<int> l(10);
    std::iota(l.begin(), l.end(), -4);
 
    std::vector<std::reference_wrapper<int>> v(l.begin(), l.end());
    // can't use shuffle on a list (requires random access), but can use it on a vector
    std::shuffle(v.begin(), v.end(), std::mt19937{std::random_device{}()});
 
    std::cout << "Contents of the list: ";
    for (int n : l) std::cout << n << ' '; std::cout << '\n';
 
    std::cout << "Contents of the list, as seen through a shuffled vector: ";
    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 << "Contents of the list, as seen through a shuffled vector: ";
    for (int i : v) std::cout << i << ' '; std::cout << '\n';
}

Possible output:

Contents of the list: -4 -3 -2 -1 0 1 2 3 4 5 
Contents of the list, as seen through a shuffled vector: -1 2 -2 1 5 0 3 -3 -4 4 
Doubling the values in the initial list...
Contents of the list, as seen through a shuffled vector: -2 4 -4 2 10 0 6 -6 -8 8

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)