Lorsque l'opérateur de déréférencement (*) est surchargé, l'utilisation de * est-elle affectée?

Question

Par exemple,

class Person{ 
     string name; 
    public: 
     T& operator*(){ 
      return name; 
     } 
     bool operator==(const Person &rhs){ 
      return this->name == rhs.name; 
     } 
     bool operator!=(const Person &rhs){ 
      return !(*this == rhs); // Will *this be the string name or the Person? 
     } 
} 

Si *this finit par déréférencement this à un string au lieu d'un Person, est-il une solution qui maintient l'utilisation de * comme opérateur de déréférencement en dehors de la classe?

Ce serait un obstacle si je ne pouvais pas surcharger * sans abandonner l'utilisation de *this.

Answer 1

Si *this finit par déréférencement this à une chaîne au lieu d'un Person, est-il une solution qui maintient l'utilisation de * comme opérateur de déréférencement en dehors de la classe?

n ° *this sera Person& ou Person const& selon la fonction. La surcharge s'applique aux objets Person et non aux pointeurs Person. this est un pointeur vers un objet Person.

Si vous utilisez:

Person p; 
auto v = *p; 

Ensuite, la surcharge operator* est appelée.

Pour appeler la surcharge operator* en utilisant this, vous devrez utiliser this->operator*() ou **this.

Answer 2

Vous avez besoin d'un objet de la classe plutôt que du pointeur vers l'objet de classe pour appeler l'opérateur surchargé *.

Person *ptr = new Person; 
Person p1 = *ptr; // does not invoke * operator but returns the object pointed by ptr 
string str = *p1 // invokes the overloaded operator as it is called on an object. 

Identique au pointeur this. Pour appeler * operator avec pointeur this, vous devrez déréférencer deux fois:

std::string str = *(*this);