Question

我有一个结构

struct A {
   void f() {}
   void g() {}
};

和一个自定义智能指针，指针指向A：

struct P {
   ...
   A* a;
};

我想以这样一种方式写P：当我写

时不会调用A :: f（）

P p;
p->f();

应该调用重载函数。但是，当我写

时，仍应调用A :: g（）

p->g();

我希望我可以通过重载P :: operator-＆gt;来实现这一点。但我没有成功。有什么建议吗？

编辑：以下是我尝试的内容：

#include <iostream>

struct A {
   void f() {}
   void g() {}
};

struct P {
   struct Wrapper
   {
      Wrapper(A* aa) : _a(aa) {}
      void f()
      {
         std::cout << "Overloaded\n";
      }
      A* operator->()
      {
         return _a;
      }
      private:
      A* _a;
   };

   Wrapper operator->()
   {
      return Wrapper(a);
   }
   private:
   A* a;
};

main()
{
   P p;
   p->f();
}

但这根本不打印，因为当我调用p-＆gt; f（）时，Wrapper :: operator-＆gt;被调用而不是Wrapper :: f（）。

Answer 1

您的P::operator->通常会返回A*原始指针。要获得所需内容，您需要一个可以返回的代理对象，它实现了这些功能。

class A_proxy
{
    A* p;
public:
    A_proxy(A* ptr) : p(ptr) {}
    void f() { /* do whatever crazy stuff you want here */ }
    void g() { p->g(); }
};

A_proxy* P::operator->()
{
    return &m_proxy;
}

这是基于评论中提出的异议的替代方法。由于指针的类型不正确，因此可能会遇到未定义的行为。

struct A_proxy : public A
{
    void f() { /* as before, crazy stuff here */ }
};

A_proxy* P::operator->()
{
    return static_cast<A_proxy*>(a);
}

重载智能指针指向的成员函数

1 个答案: