7

私の問題は単純なものです。動的に割り当てられた型へのポインターを保持するクラステンプレートがあります。間接演算子をオーバーロードして、クラステンプレートインスタンスを->演算子で参照すると、直接含まれているポインターを使用するかのようにリダイレクトされます。

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に含まれているように動作します。オペレーターに過負荷をかけることでそのギャップを埋める方法は？

4

3 に答える 3

13

あなたはただオーバーロードすることができ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*ください。誤って混乱させるのは簡単です。

于 2012-01-12T19:21:14.220 に答える
5

オペレーターをオーバーロードし->ます：

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

どちらのオーバーロードもオブジェクトを変更しないことに注意してください。それでも、オブジェクトの恒常性をポインティに遺贈するために、＃1を非定数にすることにしました。これは、「深い恒常性の伝播」またはこの種の何かと呼ばれることもあります。言語Dはこれをさらに進めます。

于 2012-01-12T19:21:54.803 に答える
3

メンバーアクセス演算子をオーバーロードして、アクセスするオブジェクトへのポインタを返すことができます。

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

また、服従演算子を使用して、ポインターのように感じさせることもできます。これは代わりに参照を返します：

T & operator*() {return *ptr;}
T const & operator*() const {return *ptr;}
于 2012-01-12T19:22:14.357 に答える