C++ 如何重载运算符->；*在C++；

有没有一种方法可以重载

->*

以用于类似智能指针的对象？下面是我想做的。为了简单起见，我没有使用模板（我将在为一个固定类工作之后再讨论）。我可以让它与指向数据成员的指针一起工作，但对于指向成员函数的指针，我似乎无法正确使用它。目前，我愿意接受只对成员函数（而不是数据成员）有效的重载。我甚至愿意接受重载，它只接受指向具有单个固定原型的成员函数的指针（例如

void func（）

）

请不要给我提供解决办法（例如，过载

*

和执行

（*obj\u ptr.*成员功能ptr）（

）。我希望

->*

能够按照代码片段中的指示工作。

请看一下Scott Meyers的作品。它已经很老了，但是我所知道的唯一讨论重载的资源是

->*

请注意，标准库的迭代器和智能指针类型不会过载

->*

。我不知道原因，但我怀疑这是因为该操作符很少使用，实现起来很麻烦，而且很容易解决。无论如何，由于标准库不支持它，您的用户也不会期望它工作

#包括
结构对象{
类型定义无效（对象：：*Met）（无效）；
满足无效（无效）{
printf（“方法调用！\n”）；
}
};
结构POBJ{
OBJ*p；
类型定义无效（*乐趣）（无效）；
静态void nop（void）{}
趣味操作员->*（OBJ:：Met m）{
printf（“操作员->*！\n”）；
//return fun（p->*m）；//在gcc中工作
（p->*m）（）；
返回nop；
}
};
内部主（空）{
OBJ-OBJ；
OBJ*pobj=&OBJ；
POBJ p；p.p=&obj；
OBJ:：Met=&OBJ:：Met；
（pobj->*met）（）；
（p->*大都会）；
}

---

有关原型，请参见，我将使用C++0x:可变模板、绑定和函数对其进行演示。我想应该可以移植它来增强：

#include <iostream>                                                             
#include <functional>                                                           

struct S
{       
  void f()
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
};

template<class C>
struct PMFSmartPtr
{
  C *p;
  template<typename C1, typename R, typename... P>
  std::function<R(P...)> operator->*(R (C1::*pmf)(P...))
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    return(std::function<R(P...)>(std::bind(pmf, p)));
  }
};

int main()
{
  PMFSmartPtr<S> x;
  void (S::*pmf)() = &S::f;
  (x->*pmf)();
  return(0);
}

#包括
#包括
结构
{       
void f（）
{
std:：cout@Tobias：在我的回答中链接到的文章也解释了这一点。严格来说，这确实满足了我提出的要求，但让操作符函数执行实际调用并返回NOP并不是我想要的。我怀疑这个解决方案不会扩展到任意原型。
返回乐趣（p->*m）
看起来像我想要的，但实际上不起作用，因为它返回一个指向独立函数的指针（一个不接受
此
指针的函数，因此无法访问类的数据成员）。如果我将数据成员添加到
OBJ
并让
met
尝试访问它们，我会遇到一个分段错误。有趣的文章，但相当令人失望，因为似乎必须返回一个函子。我不喜欢它。
#include <stdio.h>

struct OBJ {
  typedef void (OBJ::*Met)(void);
  void met( void ) {
    printf( "Method call!\n" );
  }
};

struct POBJ {
  OBJ* p;
  typedef void (*fun)(void);
  static void nop( void ) {}
  fun operator->*( OBJ::Met m ) {
    printf( "operator ->* !\n" );
//    return fun(p->*m); // works in gcc
    (p->*m)();
    return nop;
  }
};

int main( void ) {
  OBJ obj;
  OBJ* pobj = &obj;
  POBJ p; p.p = &obj;
  OBJ::Met met = &OBJ::met;
  (pobj->*met)();
  (p->*met)();
}

#include <iostream>                                                             
#include <functional>                                                           

struct S
{       
  void f()
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
};

template<class C>
struct PMFSmartPtr
{
  C *p;
  template<typename C1, typename R, typename... P>
  std::function<R(P...)> operator->*(R (C1::*pmf)(P...))
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    return(std::function<R(P...)>(std::bind(pmf, p)));
  }
};

int main()
{
  PMFSmartPtr<S> x;
  void (S::*pmf)() = &S::f;
  (x->*pmf)();
  return(0);
}