Utilisation du pointeur "This" en C++

Question

J'ai lu le pointeur "this" sur divers sites (par exemple les manuels MSDN) et je comprends ses utilisations de base - renvoyer une copie de votre propre objet ou en utilisant un pointeur de celui-ci pour les retours/comparaison.

Mais je suis tombé sur cette déclaration:

// Return an object that defines its own operator[] that will access the data. 
    // The temp object is very trivial and just allows access to the data via 
    // operator[] 
    VectorDeque2D_Inner_Set<T> operator[](unsigned int first_index) { 
    return VectorDeque2D_Inner_Set<T>(*this, first_index); 
    } 

Qu'est-ce que faire? Est-il en quelque sorte incrémenter l'opérateur, et si oui, pourquoi?

(Cela vient d'un exemple m'a donné le débordement de la pile, donc il peut y avoir des erreurs dans la syntaxe. Permettez-moi de savoir si un plus gros morceau est nécessaire, je peux coller plus code.)

---

EDIT 1
Voici la liste complète, pour plus d'informations. La fonction est proche du bas de la classe. Remarque: j'ai renommé la variable de x en index et renommé la classe interne basée sur un modèle. J'ai oublié de mettre le modèle dans la classe interne du modèle, que j'ai ajouté dans cette mise à jour.

Des idées maintenant?

template <typename T> 
class Container 
{ 
private: 
    // ... 


public: 

    // Proxy object used to provide the second brackets 
    template <typename T> 
    class OperatorBracketHelper 
    { 
     Container<T> & parent; 
     size_t firstIndex; 
    public: 
     OperatorBracketHelper(Container<T> & Parent, size_t FirstIndex) : parent(Parent), firstIndex(FirstIndex) {} 

     // This is the method called for the "second brackets" 
     T & operator[](size_t SecondIndex) 
     { 
      // Call the parent GetElement method which will actually retrieve the element 
      return parent.GetElement(firstIndex, SecondIndex); 
     } 

    } 

    // This is the method called for the "first brackets" 
    OperatorBracketHelper<T> operator[](size_t FirstIndex) 
    { 
     // Return a proxy object that "knows" to which container it has to ask the element 
     // and which is the first index (specified in this call) 
     return OperatorBracketHelper<T>(*this, FirstIndex); 
    } 

    T & GetElement(size_t FirstIndex, size_t SecondIndex) 
    { 
     // Here the actual element retrieval is done 
     // ... 
    } 
} 

Answer 1

Le mot-clé this est fondamentalement une référence de pointeur à l'objet en cours d'utilisation. En C++, ce est un pointeur, donc pour le déréférencer, utilisez *this.

Ainsi, ce code,

return VectorDeque2D_Inner_Set<T>(*this, index); 

retourne une nouvelle VectorDeque2D_Inner_Set en passant un déréférencé de lui-même (puisque le constructeur veut la référence de l'objet et non l'adresse de pointeur).

Cette méthode,

// This is the method called for the "first brackets" 
    OperatorBracketHelper<T> operator[](size_t FirstIndex) 
    { 
     // Return a proxy object that "knows" to which container it has to ask the element 
     // and which is the first index (specified in this call) 
     return OperatorBracketHelper<T>(*this, FirstIndex); 
    } 

vient d'adopter une self déréférencé au constructeur OperatorBracketHelper car il a besoin d'un Container& comme paramètre.

Answer 2

L'opérateur * déréférence le pointeur this. Ceci est nécessaire car la méthode appelée (constructeur OperatorBracketHelper(Container<T> & Parent, size_t FirstIndex)) nécessite une référence plutôt qu'un pointeur.

Est-ce un modèle d'échec? Je ne sais pas. Cela me semble instinctif, mais je ne trouve rien de mal à cela.

Answer 3

il crée une instance de OpBracketHelper avec la référence au conteneur actuel comme membre parent (* ce passe dans une référence à l'objet conteneur au constructeur)

Mon seul souci serait d'environ la durée de vie de la Conteneur et l'objet auxiliaire. Je serais tenté d'utiliser shared_ptr plutôt qu'une référence