Surcharge de l'opérateur d'indirection en c ++ [double]

Question

Cette question a déjà une réponse ici:

• Comment surcharger l'opérateur indirection? (C ++) 2 réponses

mon problème est simple. J'ai un modèle de classe qui tient un pointeur vers un type alloué dynamiquement. Je veux surcharger l'opérateur indirection de telle sorte que se référant à l'instance de modèle de classe avec le -.> Opérateur je redirigés comme si j'utilise le pointeur directement contenu dans

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

Créer maclasse d'un certain type:

MyClass<SomeObject> instance;

Alors, ce que je veux est au lieu d'avoir à taper:

instance.ptr->someMemberMethod();

Je tapez simplement:

intance->someMemberMethod();

Même tu instance n'est pas un pointeur, il se comporte comme si elle est le pointeur instance contient. Comment combler cette lacune par une surcharge de l'opérateur?

Answer 1

Vous pouvez simplement surcharger operator-> et 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;
    }
};

Notez que, en raison d'une décision de conception par le créateur de la langue, vous ne pouvez pas surcharger l'opérateur ..

, on pourrait penser aussi que operator* surchargerait le multiplication opérateur au lieu de l'opérateur de déréférencement. Cependant, ce n'est pas le cas, car l'opérateur de multiplication prend un seul argument (alors que l'opérateur de déréférencement ne prend aucun argument), et à cause de cela, le compilateur peut dire que l'on est qui.

Enfin, notez que operator-> renvoie un pointeur, mais operator* renvoie une référence. Il est facile de les confondre accidentellement.

Answer 2

surcharge l'opérateur ->:

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

Notez que à la fois ne mute pas de surcharge l'objet; Néanmoins, nous décidons de faire # 1 non-const, de sorte que nous lègue constness de l'objet sur le pointée. Cela est parfois appelé « propagation de constness profonde » ou quelque chose de ce genre. Le langage D prend ce beaucoup plus loin.

Answer 3

L'opérateur d'accès au membre peut être surchargé pour renvoyer un pointeur vers l'objet auquel on doit accéder:

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

Vous pouvez également l'opérateur de déférence, de lui faire sentir encore plus comme un pointeur; ceci retourne une référence au lieu:

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