在 c++ 中重载间接运算符

Question

我的问题很简单。我有一个类模板，其中包含指向动态分配类型的指针。我想重载间接运算符，以便使用 -> 引用类模板实例。运算符我被重定向，就像我直接使用其中包含的指针一样。

template<class T>
class MyClass
 {
  T *ptr;
  ...
  // created dynamic resource for ptr in the constructor
 };

创建某种类型的 myclass：

MyClass<SomeObject> instance;

所以我想要的是不必键入：

instance.ptr->someMemberMethod();

我只需键入：

intance->someMemberMethod();

即使你 instance 不是一个指针，它的行为就好像它是指针 instance > 包含。如何通过重载操作符来弥补这一差距？

Answer 1

您可以只重载 operator-> 和 operator*：

template<class T>
class MyClass
{
    T* ptr;

public:
    T* operator->() {
        return ptr;
    }

    // const version, returns a pointer-to-const instead of just a pointer to
    // enforce the idea of the logical constness of this object 
    const T* operator->() const {
        return ptr;
    }

    T& operator*() {
        return *ptr;
    }

    // const version, returns a const reference instead of just a reference
    // to enforce the idea of the logical constness of this object
    const T& operator*() const {
        return *ptr;
    }
};

请注意，由于语言创建者的设计决定，您不能重载 . 运算符。

另外，您可能认为 operator* 会重载乘法运算符，而不是取消引用运算符。然而，情况并非如此，因为乘法运算符采用单个参数（而解引用运算符不采用任何参数），因此编译器可以区分哪个是哪个。

最后，请注意 operator-> 返回一个指针，但 operator* 返回一个引用。很容易不小心将它们混淆。

Answer 2

重载 -> 运算符：

template <typename T> class MyClass
{
    T * p;
public:
    T       * operator->()       { return p; }  // #1
    T const * operator->() const { return p; }
};

请注意，两个重载都不会改变对象；尽管如此，我们还是决定将 #1 设为非常量，以便将对象的常量性遗赠给指针对象。这有时被称为“深度常量传播”或类似的东西。语言 D 更进一步。

Answer 3

可以重载成员访问运算符以返回指向要访问的对象的指针：

T * operator->() {return ptr;}
T const * operator->() const {return ptr;}

您可能还需要引用运算符，以使其感觉更像指针；这会返回一个引用：

T & operator*() {return *ptr;}
T const & operator*() const {return *ptr;}