Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/utility/functional/reference wrapper"

From cppreference.com
< cpp‎ | utility‎ | functional
m (c++17)
(Printing the unshuffled list must be done before the call to random_shuffle().)
Line 62: Line 62:
 
     std::list<int> l = {-4, -3, -2, -1, 0, 1, 2, 3, 4};
 
     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: ";
 
     std::cout << "Contents of the list: ";
 
     for (int n : l) {
 
     for (int n : l) {
Line 70: Line 67:
 
     }
 
     }
 
     std::cout << '\n';
 
     std::cout << '\n';
 +
 +
    std::vector<std::reference_wrapper<int>> v(l.begin(), l.end());
 +
    std::random_shuffle(v.begin(), v.end());
  
 
     std::cout << "Contents of the list, shuffled: ";
 
     std::cout << "Contents of the list, shuffled: ";

Revision as of 03:48, 16 November 2014

 
C++
 
Utilities library
General utilities
Relational operators (deprecated in C++20)
 
Function objects
Function invocation
(C++17)(C++23)
Identity function object
(C++20)
Reference wrappers
reference_wrapper
(C++11)
(C++11)(C++11)
(C++20)(C++20)
Transparent operator wrappers
(C++14)
(C++14)
(C++14)
(C++14)  
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)

Old binders and adaptors
(until C++17*)
(until C++17*)
(until C++17*)
(until C++17*)
(until C++17*)  
(until C++17*)
(until C++17*)(until C++17*)(until C++17*)(until C++17*)
(until C++20*)
(until C++20*)
(until C++17*)(until C++17*)
(until C++17*)(until C++17*)

(until C++17*)
(until C++17*)(until C++17*)(until C++17*)(until C++17*)
(until C++20*)
(until C++20*)
 
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) which cannot normally hold references.

Specifically, std::reference_wrapper is a Template:concept and Template:concept 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 Template:concept

(since C++17)

Contents

Member types

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

Member functions

 stores a reference in a new std::reference_wrapper object
(public member function) [edit]
rebinds a std::reference_wrapper
(public member function) [edit]
accesses the stored reference
(public member function) [edit]
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::cout << "Contents of the list: ";
    for (int n : l) {
        std::cout << n << ' ';
    }
    std::cout << '\n';
 
    std::vector<std::reference_wrapper<int>> v(l.begin(), l.end());
    std::random_shuffle(v.begin(), v.end());
 
    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

See also

(C++11)(C++11)
 creates a std::reference_wrapper with a type deduced from its argument
(function template) [edit]
(C++11)
 binds one or more arguments to a function object
(function template) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/reference_wrapper&oldid=73784"