public member function
<functional>

std::reference_wrapper::operator()

template <class... ArgTypes>  typename result_of<type&(ArgTypes&&...)>::type    operator() (ArgTypes&&... args) const;
访问元素 (函数形式)
访问被引用的元素。

效果取决于 reference_wrapper 对象引用的类型(即其类模板参数 T,别名为成员 type

  • 如果 type 是一个 *函数* 或一个 *函数对象类型*,则调用它并向前传递参数给函数。
  • 如果 type 是一个 *指向非静态成员函数的指针*,则使用第一个参数作为调用成员的对象(这可能是一个对象、引用或指向它的指针),并将剩余的参数转发给函数。
  • 如果 type 是一个 *指向非静态数据成员的指针*,它应该用单个参数调用,并且该函数返回对其参数成员的引用(该参数可以是一个对象、引用或指向它的指针)。

参数

args...
调用的参数。
如果 type 是一个 *成员指针*,第一个参数应为定义该成员的对象(或其引用或指针)。

返回值

如果函数执行函数调用,则返回该函数的返回值。
否则,它返回被访问成员的引用。

type 是描述被引用类型的成员类型(它是类模板参数 T 的别名)。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// reference_wrapper::operator()
#include <iostream>     // std::cout
#include <functional>   // std::reference_wrapper, std::plus

struct AB {
  int a,b;
  int sum() {return a+b;}
};

 int ten() {return 10;}            // function

int main () {
  std::plus<int> plus_ints;        // function object
  int AB::* p_a = &AB::a;          // pointer to data member
  int(AB::* p_sum)() = &AB::sum;   // pointer to member function

  // construct reference_wrappers using std::ref:
  auto ref_ten = std::ref(ten);             // function
  auto ref_plus_ints = std::ref(plus_ints); // function object
  auto ref_AB_sum = std::ref(p_sum);        // pointer to member function
  auto ref_AB_a = std::ref(p_a);            // pointer to data member

  AB ab {100,200};

  // invocations:
  std::cout << ref_ten() << '\n';
  std::cout << ref_plus_ints(5,10) << '\n';
  std::cout << ref_AB_sum(ab) << '\n';
  std::cout << ref_AB_a( ab) << '\n';
  std::cout << ref_AB_a(&ab) << '\n';       // (also ok with pointer)

  return 0;
}

输出
10
15
300
100
100


数据竞争

对象及其引用的元素都会被访问。

异常安全

提供与被访问元素相同的级别。

另见