template<typename _Tp>
 class reference_wrapper
 : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
 {
  _Tp* _M_data;

 public:
  typedef _Tp type;

  reference_wrapper(_Tp& __indata) noexcept
  : _M_data(std::__addressof(__indata))
  { }

  reference_wrapper(_Tp&&) = delete;

  reference_wrapper(const reference_wrapper&) = default;

  reference_wrapper&
  operator=(const reference_wrapper&) = default;
  //operator的隱式類型轉(zhuǎn)換
  operator _Tp&() const noexcept
  { return this->get(); }

  _Tp&
  get() const noexcept
  { return *_M_data; }

  template<typename... _Args>
 typename result_of<_Tp&(_Args&&...)>::type
 operator()(_Args&&... __args) const
 {
  return __invoke(get(), std::forward<_Args>(__args)...);
 }
 };

operator _Tp&() const noexcept
  { return this->get(); }

#include <iostream>
/*
 *
 * c++ operator的隱式類型轉(zhuǎn)換
 * 參見std::ref的實現(xiàn)
 */ 
void f(int a)
{
 std::cout << "a = " << a << std::endl;
}
class A{
 public:
 A(int a):num(a){}
 ~A() {}

 operator int()
 {
  return num;
 }
 int num;
};

int main()
{
 A a(1);
 std::cout << a + 1 << std::endl;
 f(a);
 return 0;
}

#include <iostream>
/*
 *
 * c++ 構(gòu)造的隱式類型轉(zhuǎn)換
 * 參見std::ref的實現(xiàn)
 */
class B{
 public:
 B(int a):num(a){}
 ~B() {}

 int num;
};

class A{
 public:
 A(int a):num(a){}
 A(B b):num(b.num){}
 ~A() {}

 int fun(A a)
 {
  std::cout << num + a.num << std::endl;
 }

 int num;
};

int main()
{
 B b(1);
 A a(2);
 //通過構(gòu)造函數(shù)實現(xiàn)了隱式類型轉(zhuǎn)換
 a.fun(b); //輸出結(jié)果為3
 return 0;
}

class A{
 public:
 A(int a):num(a){}
 explicit A(B b):num(b.num){}
 ~A() {}

 int fun(A a)
 {
  std::cout << num + a.num << std::endl;
 }

 int num;
};

int main()
{
 B b(1);
 A a(2);
 a.fun(A(b));
 return 0;
}