opérateur surcharge en C++

Question

struct T 
{ 
     int a; 
     int b; 
}; 

class Ptr 
{ 
public: 
     Ptr(int a, int b) { t_.a = a; t_.b = b; } 
     T* operator->() {return &t_;} 
     T& operator*() {return t_;} 

private: 
     T t_; 
}; 

int main() 
{ 
     Ptr ptr(1, 2); 
     cout << "a = " << ptr->a << " b = " << ptr->b << endl; 
     cout << "a = " << ptr.operator->()->a << " b = " << ptr.operator->()->b << endl; 
} 

Sortie:

a = 1 b = 2 
a = 1 b = 2 

Pourquoi ptr->a la même chose que ptr.operator->()->a, quel est le principe en elle?

Answer 1

C'est la règle. En surchargeant l'opérateur -> il doit renvoyer soit un pointeur soit quelque chose d'autre qui a surchargé l'opérateur -> et cet opérateur est appliqué récursivement jusqu'à ce qu'un pointeur soit retourné. Et l'evenutal -> est appliqué à ce pointeur. La règle a du sens. Sinon, vous vous attendez à ce que l'opérateur -> prenne un autre argument. Mais de quel type? chaîne? Naturellement non. Je veux dire, pensez-y, c'est le moyen le plus (sinon le seul) raisonnable. Dans ce sens, l'opérateur -> peut être considéré comme une exception.

Answer 2

Parce que c'est comment cet opérateur surchargé fonctionne ...

Une expression x->m est interprété comme (x.operator->())->m pour un objet de classe x de type T si T::operator->() existe et si l'opérateur est sélectionné comme la meilleure fonction match par le mécanisme de résolution de surcharge.

(C++ § [over.ref]/1)