命名空间
变体
操作

std::reference_wrapper

来自 cppreference.com
< cpp‎ | utility‎ | functional
 
C++
 
实用程序库
语言支持
类型支持 (基本类型，RTTI)
库功能测试宏 (C++20)
动态内存管理
程序实用程序
协程支持 (C++20)
可变参数函数
(C++20)
(C++26)
(C++11)
(C++20)
调试支持
(C++26)
(C++26)
(C++26)
三方比较
(C++20)(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)   
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
通用实用程序
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (在 C++20 中弃用)
整数比较函数
(C++20)(C++20)(C++20)   
(C++20)
交换 和 类型操作
(C++20)
(C++14)
(C++11)
(C++23)
(C++11)
(C++23)
(C++11)
(C++11)
(C++17)
通用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++11)
(C++17)
(C++17)
(C++23)
基本字符串转换
(C++17)
(C++17)
(C++17)

 
函数对象
函数调用
(C++17)(C++23)
标识函数对象
(C++20)
引用包装器
reference_wrapper
(C++11)
(C++11)(C++11)
(C++20)(C++20)
透明运算符包装器
(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)

旧的绑定器和适配器
(直到 C++17*)
(直到 C++17*)
(直到 C++17*)
(直到 C++17*)
(直到 C++17*)  
(直到 C++17*)
(直到 C++17*)(直到 C++17*)(直到 C++17*)(直到 C++17*)
(直到 C++20*)
(直到 C++20*)
(直到 C++17*)(直到 C++17*)
(直到 C++17*)(直到 C++17*)

(直到 C++17*)
(直到 C++17*)(直到 C++17*)(直到 C++17*)(直到 C++17*)
(直到 C++20*)
(直到 C++20*)
 
std::reference_wrapper
 
在头文件 <functional> 中定义
template< class T >
class reference_wrapper;
 (自 C++11 起)

std::reference_wrapper 是一个类模板，它将一个引用包装在一个可复制、可分配的对象中。

具体来说，std::reference_wrapper 是对类型为 T 的对象引用或函数引用的一个 CopyConstructible 和 CopyAssignable 包装器。std::reference_wrapper 的实例是对象（它们可以被复制或存储在容器中），但它们可以隐式转换为 T&，这样它们就可以用作接受底层类型引用的函数的参数。

如果存储的引用是 Callable，std::reference_wrapper 可以用相同的参数调用。

辅助函数 std::ref 和 std::cref 通常用于生成 std::reference_wrapper 对象。

std::reference_wrapper 用于将对象引用传递给 std::bind，std::thread 的构造函数，或辅助函数 std::make_pair 和 std::make_tuple。它也可以用作一种机制，将引用存储在标准容器（如 std::vector）中，这些容器通常不能保存引用。

std::reference_wrapper 保证是 TriviallyCopyable。

 (自 C++17 起)

T 可以是不完整类型。

 (自 C++20 起)

内容

[编辑] 成员类型

type 定义
type T
result_type
(在 C++17 中弃用)
(在 C++20 中移除) 		如果 T 是函数，则为 T 的返回类型。否则，未定义。
argument_type
(在 C++17 中弃用)
(在 C++20 中移除)
  • 如果 T 是函数或指向接受类型为 A1 的一个参数的函数的指针，则 argument_type 为 A1
  • 如果 T 是指向类 T0 的成员函数的指针，该函数不接受参数，则 argument_type 为 T0*，可能具有 cv 限定
  • 如果T是具有成员类型T::argument_type的类类型，则argument_type是该类型的别名。
first_argument_type
(在 C++17 中弃用)
(在 C++20 中移除)
  • 如果T是接受类型为A1和A2的两个参数的函数或指向函数的指针，则first_argument_type为A1。
  • 如果T是类T0的指向成员函数的指针，该函数接受一个参数，则first_argument_type为T0*，可能被cv限定。
  • 如果T是具有成员类型T::first_argument_type的类类型，则first_argument_type是该类型的别名。
second_argument_type
(在 C++17 中弃用)
(在 C++20 中移除)
  • 如果T是接受类型为A1和A2的两个参数的函数或指向函数的指针，则second_argument_type为A2。
  • 如果T是类T0的指向成员函数的指针，该函数接受一个参数A1，则second_argument_type为A1，可能被cv限定。
  • 如果T是具有成员类型T::second_argument_type的类类型，则second_argument_type是该类型的别名。

[编辑] 成员函数

 将引用存储在新的std::reference_wrapper对象中。
(公有成员函数) [编辑]
 重新绑定std::reference_wrapper。
(公有成员函数) [编辑]
 访问存储的引用。
(公有成员函数) [编辑]
 调用存储的函数。
(公有成员函数) [编辑]

[编辑] 非成员函数

(C++26)
 将reference_wrapper对象与其存储的引用进行比较。
(函数) [编辑]

[编辑] 推导指南(自C++17起)

[编辑] 辅助类

(C++23)
 确定reference_wrapper和非reference_wrapper的公共引用类型。
(类模板特化) [编辑]

[编辑] 可能的实现

namespace detail
{
    template<class T> constexpr T& FUN(T& t) noexcept { return t; }
    template<class T> void FUN(T&&) = delete;
}
 
template<class T>
class reference_wrapper
{
public:
    // types
    using type = T;
 
    // construct/copy/destroy
    template<class U, class = decltype(
        detail::FUN<T>(std::declval<U>()),
        std::enable_if_t<!std::is_same_v<reference_wrapper, std::remove_cvref_t<U>>>()
    )>
    constexpr reference_wrapper(U&& u)
        noexcept(noexcept(detail::FUN<T>(std::forward<U>(u))))
        : _ptr(std::addressof(detail::FUN<T>(std::forward<U>(u)))) {}
 
    reference_wrapper(const reference_wrapper&) noexcept = default;
 
    // assignment
    reference_wrapper& operator=(const reference_wrapper& x) noexcept = default;
 
    // access
    constexpr operator T& () const noexcept { return *_ptr; }
    constexpr T& get() const noexcept { return *_ptr; }
 
    template<class... ArgTypes>
    constexpr std::invoke_result_t<T&, ArgTypes...>
        operator() (ArgTypes&&... args ) const
            noexcept(std::is_nothrow_invocable_v<T&, ArgTypes...>)
    {
        return std::invoke(get(), std::forward<ArgTypes>(args)...);
    }
 
private:
    T* _ptr;
};
 
// deduction guides
template<class T>
reference_wrapper(T&) -> reference_wrapper<T>;

[编辑] 示例

演示了std::reference_wrapper作为引用容器的使用，这使得可以使用多个索引访问同一个容器成为可能。

运行此代码
#include <algorithm>
#include <functional>
#include <iostream>
#include <list>
#include <numeric>
#include <random>
#include <vector>
 
void println(auto const rem, std::ranges::range auto const& v)
{
    for (std::cout << rem; auto const& e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::list<int> l(10);
    std::iota(l.begin(), l.end(), -4);
 
    // can't use shuffle on a list (requires random access), but can use it on a vector
    std::vector<std::reference_wrapper<int>> v(l.begin(), l.end());
 
    std::ranges::shuffle(v, std::mt19937{std::random_device{}()});
 
    println("Contents of the list: ", l);
    println("Contents of the list, as seen through a shuffled vector: ", v);
 
    std::cout << "Doubling the values in the initial list...\n";
    std::ranges::for_each(l, [](int& i) { i *= 2; });
 
    println("Contents of the list, as seen through a shuffled vector: ", v);
}

可能的输出

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

[编辑] 另请参阅

(C++11)(C++11)
 创建一个std::reference_wrapper，其类型从其参数推断得出。
(函数模板) [编辑]
(C++11)
 将一个或多个参数绑定到函数对象。
(函数模板) [编辑]
(C++20)(C++20)
 获取包装在std::reference_wrapper中的引用类型。
(类模板) [编辑]
取自 "https://cppreference.cn/mwiki/index.php?title=cpp/utility/functional/reference_wrapper&oldid=173390"