View source for cpp/utility/functional/reference wrapper

← cpp/utility/functional/reference wrapper

You do not have permission to edit this page, for the following reasons:

The action you have requested is limited to users in one of the groups: Users, Administrators.

Due to recent vandalism, editing of this page is temporarily disabled for new users.If you want to suggest a change, please leave a message on the suggestions page for new users instead (don't be surprised if that page appears vandalized!).

You can view and copy the source of this page.

{{cpp/title|reference_wrapper}}
{{cpp/utility/functional/reference_wrapper/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | since=c++11 |
template< class T >
class reference_wrapper;
}}
{{dcl end}}

{{tt|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 {{lc|std::vector}}) which cannot normally hold references.

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

If the stored reference is {{concept|Callable}}, {{tt|std::reference_wrapper}} is callable with the same arguments.

Helper functions {{lc|std::ref}} and {{lc|std::cref}} are often used to generate {{tt|std::reference_wrapper}} objects. 

{{tt|std::reference_wrapper}} is also used to pass objects to {{lc|std::bind}} or to the constructor of {{lc|std::thread}} by reference.

{{rev begin}}
{{rev|since=c++17|
{{tt|std::reference_wrapper}} is guaranteed to be {{concept|TriviallyCopyable}}.
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|type}} | {{tt|T}}}}
{{dsc | {{tt|result_type}}{{mark|deprecated in C++17}}{{mark until c++20|removed=yes}} | The return type of {{tt|T}} if {{tt|T}} is a function. Otherwise, not defined }}
{{dsc | {{tt|argument_type}}{{mark|deprecated in C++17}}{{mark until c++20|removed=yes}} | 1) if {{tt|T}} is a function or pointer to function that takes one argument of type {{tt|A1}},  then {{tt|argument_type}} is {{tt|A1}}.<br>
2) if {{tt|T}} is a pointer to member function of class {{tt|T0}} that takes no arguments, then {{tt|argument_type}} is {{tt|T0*}}, possibly cv-qualified<br>
3) if {{tt|T}} is a class type with a member type {{tt|T::argument_type}}, then {{tt|argument_type}} is an alias of that}}
{{dsc | {{tt|first_argument_type}}{{mark|deprecated in C++17}}{{mark until c++20|removed=yes}} | 1) if {{tt|T}} is a function or pointer to function that takes two arguments of types {{tt|A1}} and {{tt|A2}}, then {{tt|first_argument_type}} is {{tt|A1}}.<br>
2) if {{tt|T}} is a pointer to member function of class {{tt|T0}} that takes one argument, then {{tt|first_argument_type}} is {{tt|T0*}}, possibly cv-qualified<br>
3) if {{tt|T}} is a class type with a member type {{tt|T::first_argument_type}}, then {{tt|first_argument_type}} is an alias of that
}}
{{dsc | {{tt|second_argument_type}}{{mark|deprecated in C++17}}{{mark until c++20|removed=yes}} |1) if {{tt|T}} is a function or pointer to function that takes two arguments of type s {{tt|A1}} and {{tt|A2}}, then {{tt|second_argument_type}} is {{tt|A2}}.<br>
2) if {{tt|T}} is a pointer to member function of class {{tt|T0}} that takes one argument {{tt|A1}}, then {{tt|second_argument_type}} is {{tt|A1}}, possibly cv-qualified<br>
3) if {{tt|T}} is a class type with a member type {{tt|T::second_argument_type}}, then {{tt|second_argument_type}} is an alias of that}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc constructor}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc operator{{=}} }}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc get}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc operator()}}
{{dsc end}}

===[[cpp/utility/functional/reference_wrapper/deduction_guides|Deduction guides]]{{mark since c++20}}===

===Possible implementation===
{{eq fun
 | 1=
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 >
  std::invoke_result_t<T&, ArgTypes...>
    operator() ( ArgTypes&&... args ) const {
    return std::invoke(get(), std::forward<ArgTypes>(args)...);
  }
 
private:
  T* _ptr;
};

// deduction guides
template<class T>
reference_wrapper(reference_wrapper<T>) -> reference_wrapper<T>;
}}

===Example===
{{example
 | Demonstrates the use of reference_wrapper as a container of references, which makes it possible to access the same container using multiple indexes
 | 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 << "\nContents of the list, as seen through a shuffled vector: ";
    for (int i : v){
        std::cout << i << ' ';
    }

    std::cout << "\n\nDoubling the values in the initial list...\n\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 << ' ';
    }
}
|p=true
| 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===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc ref}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc end}}

[[de:cpp/utility/functional/reference wrapper]]
[[es:cpp/utility/functional/reference wrapper]]
[[fr:cpp/utility/functional/reference wrapper]]
[[it:cpp/utility/functional/reference wrapper]]
[[ja:cpp/utility/functional/reference wrapper]]
[[pt:cpp/utility/functional/reference wrapper]]
[[ru:cpp/utility/functional/reference wrapper]]
[[zh:cpp/utility/functional/reference wrapper]]

Templates used on this page:

Template:!- (view source)
Template:== (view source)
Template:c (view source) (protected)
Template:c/core (view source) (protected)
Template:cpp/navbar content (view source)
Template:cpp/navbar heading (view source)
Template:cpp/title (view source) (protected)
Template:cpp/utility/functional/dsc bind (view source)
Template:cpp/utility/functional/dsc ref (view source)
Template:cpp/utility/functional/dsc unwrap reference (view source)
Template:cpp/utility/functional/navbar content (view source)
Template:cpp/utility/functional/navbar heading (view source)
Template:cpp/utility/functional/reference wrapper/dsc basic common reference (view source)
Template:cpp/utility/functional/reference wrapper/dsc constructor (view source)
Template:cpp/utility/functional/reference wrapper/dsc get (view source)
Template:cpp/utility/functional/reference wrapper/dsc operator() (view source)
Template:cpp/utility/functional/reference wrapper/dsc operator= (view source)
Template:cpp/utility/functional/reference wrapper/dsc operator cmp (view source)
Template:cpp/utility/functional/reference wrapper/navbar (view source)
Template:cpp/utility/functional/reference wrapper/navbar content (view source)
Template:cpp/utility/functional/reference wrapper/navbar heading (view source)
Template:cpp/utility/navbar content (view source)
Template:cpp/utility/navbar heading (view source)
Template:ctitle (view source) (protected)
Template:dcl (view source) (protected)
Template:dcl/std (view source) (semi-protected)
Template:dcl begin (view source) (protected)
Template:dcl end (view source) (protected)
Template:dcl header (view source) (protected)
Template:dcl list header/link (view source)
Template:dcl sep (view source) (protected)
Template:dsc (view source) (protected)
Template:dsc begin (view source) (protected)
Template:dsc editlink (view source)
Template:dsc end (view source) (protected)
Template:dsc fun (view source) (protected)
Template:dsc guard (view source) (protected)
Template:dsc header/link (view source)
Template:dsc hitem (view source) (protected)
Template:dsc inc (view source) (protected)
Template:dsc mark mem (view source) (protected)
Template:dsc mem ctor (view source) (protected)
Template:dsc mem fun (view source) (protected)
Template:dsc member (view source) (protected)
Template:dsc ptclass (view source) (protected)
Template:dsc small (view source)
Template:dsc tclass (view source) (protected)
Template:dsc tfun (view source) (protected)
Template:eq fun (view source) (protected)
Template:example (view source) (protected)
Template:get lang (view source) (protected)
Template:l2tt/core (view source) (protected)
Template:langlinks (view source) (protected)
Template:langlinks/one (view source) (protected)
Template:lc (view source) (protected)
Template:lines (view source) (protected)
Template:ls (view source)
Template:lsd (view source)
Template:ltt (

cppreference.com

Search

Namespaces

Variants

Views

Actions

View source for cpp/utility/functional/reference wrapper