Question Quel est le but d'un "this" pointeur en C ++? [dupliquer]


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

Quel est le but de this mot-clé. Les méthodes d'une classe n'ont-elles pas accès à d'autres membres homologues de la même classe? Quel est le besoin d'appeler un this appeler des méthodes homologues dans une classe?


16
2018-05-13 17:21


origine


Réponses:


Deux utilisations principales:

  1. Passer *this ou this en tant que paramètre pour d'autres méthodes non classées.

    void do_something_to_a_foo(Foo *foo_instance);
    
    void Foo::DoSomething()
    {
        do_something_to_a_foo(this);
    }
    
  2. Pour vous permettre de supprimer les ambiguïtés entre les variables membres et les paramètres de fonction. Ceci est courant dans les constructeurs.
    MessageBox::MessageBox(const string& message)
    {
      this->message = message;
    }
    (Bien qu'un liste d'initialisation est généralement préférable à l'affectation dans cet exemple particulier.)

34
2018-05-13 17:28



  • Aide à désambiguïser les variables.
  • Passez en paramètre ou retournez-vous en résultat

Exemple:

struct A
{
    void test(int x)
    {
        this->x = x;                 // Disambiguate. Show shadowed variable.
    }
    A& operator=(A const& copy)
    {
        x = copy.x;
        return *this;                // return a reference to self
    }

    bool operator==(A const& rhs) const
    {
         return isEqual(*this, rhs); // Pass yourself as parameter.
                                     // Bad example but you can see what I mean.
    }

    private:
        int x;
};

13
2018-05-13 17:23



Considérez le cas où un paramètre a le même nom qu'un membre de classe:

void setData(int data){
  this->data = data;
}

3
2018-05-13 17:23



  1. Résoudre l'ambiguïté entre les variables / fonctions membres et celles définies dans les autres étendues
  2. Expliquez clairement à un lecteur du code qu'une fonction membre est appelée ou qu'une variable membre est référencée.
  3. Déclenchez IntelliSense dans l'EDI (même si c'est peut-être moi).

3
2018-05-13 17:31



L'expression *this est couramment utilisé pour renvoyer l'objet actuel depuis une fonction membre:

return *this;

le this le pointeur est également utilisé pour se protéger contre la référence à soi:

if (&Object != this) {
// do not execute in cases of self-reference

3
2018-05-13 17:29



Il vous permet de passer l'objet actuel à une autre fonction:

class Foo;

void FooHandler(Foo *foo);

class Foo
{
    HandleThis()
    {
       FooHandler(this);
    }  
};

2
2018-05-13 17:26



Quelques points à retenir

  • Ce pointeur stocke l'adresse de l'instance de classe, pour activer le pointeur accès des membres au membre fonctions de la classe.

  • Ce pointeur n'est pas pris en compte calculer la taille de l'objet.

  • Ces pointeurs ne sont pas accessibles pour fonctions membres statiques.

  • Ces pointeurs ne sont pas modifiables

Regardez l'exemple suivant pour comprendre comment utiliser le pointeur 'this' expliqué dans ce didacticiel C ++.

class this_pointer_example // class for explaining C++ tutorial 
{
    int data1;
 public:
    //Function using this pointer for C++ Tutorial
    int getdata()
    { 
        return this->data1;
    } 
  //Function without using this pointer 
  void setdata(int newval)
  {
       data1 = newval;
  }
};

Ainsi, une fonction membre peut accéder au membre de données en utilisant ce pointeur ou non. Lire aussi ce comprendre certaines choses de base sur ce pointeur


2
2018-05-13 17:32



Il vous permet de contourner les membres ombrés par des arguments de méthode ou des variables locales.


1
2018-05-13 17:23



le this Le pointeur à l'intérieur d'une classe est une référence à lui-même. Il est nécessaire par exemple dans ce cas:

class YourClass
{
   private:
      int number;

   public:
      YourClass(int number)
      {
         this->number = number;
      }
}

(alors que cela aurait été mieux fait avec une liste d'initialisation, cela sert à la démonstration)

Dans ce cas, vous avez 2 variables avec le même nom

  1. Le "numéro" privé de la classe
  2. Et paramètre constructeur "nombre"

En utilisant this->number, vous indiquez au compilateur que vous affectez la variable class-private.


1
2018-05-13 17:24



Par exemple, si vous écrivez un operator=() vous devez vérifier pour l'auto-assignation.

class C {
public:
    const C& operator=(const C& rhs)
    {
        if(this==&rhs) // <-- check for self assignment before anything
            return *this;
        // algorithm of assignment here
        return *this; // <- return a reference to yourself
    }
};

1
2018-05-13 17:28



le this le pointeur est un moyen d'accéder à l'instance actuelle d'un objet particulier. Il peut être utilisé à plusieurs fins:

  • en tant que représentation d'identité (par exemple en comparaison avec d'autres instances)
  • pour les membres de données et la désambiguïsation des variables locales
  • passer l'instance actuelle à des objets externes
  • pour convertir l'instance actuelle en un type différent

1
2018-05-13 17:28