Quelle est la convention pour appeler overloaded = opérateur en C++ en utilisant des pointeurs?

Question

Lorsque la surcharge d'un « = » opérateur pour une classe, la syntaxe habituelle est:

ClassA ObjA, ObjB; 

ObjA = ObjB; 

Mais qu'en pointeurs ??

Class *PtrA, *PtrB; 

PtrA->operator=(PtrB) 

est la convention d'appel ci-dessus correcte en supposant l'opérateur = dans ClassA est défini pour le pointeur sur la classe (ClassA* operator=(const ClassA* obj)) ??

Answer 1

Habituellement, l'opérateur d'affectation sera définie que pour la classe, et non les pointeurs, et vous pouvez faire:

*ptrA = *ptrB; 

Answer 2

pas que dans votre exemple

Class *PtrA, *PtrB; 

PtrA->operator=(PtrB) 

Vous ne passent pas dans une instance de PtrB, vous passez dans un pointeur vers un PtrB;

En fait, bien sûr, votre code n'a pas vraiment de sens. Vous ne pouvez pas dire

Class *PtrA, *PtrB; 

Je pense que vous voulez dire

Class A 
{ 
} 
Class B 
{ 
    B operator=(const A &rhs){...} 
} 

A *ptra = ... 
B *ptrb = ... 

Dans ce cas, vous pouvez aller

*ptrb = *ptra; 

ou

ptrb->operator=(*ptra); 

vous ne pouvez certainement pas aller

ptrb->operator=(ptra) 

ou (la syntaxe simple équivalent)

*ptrbb = ptra 

Answer 3

Si l'opérateur assignement en ClassA accepte un argument de type ClassA * (ou const ClassA *), alors vous pouvez l'appeler comme soit

PtrA->operator =(PtrB); 

ou

*PtrA = PtrB; 

Ce dernier est une manière plus naturelle d'utiliser l'opérateur d'assigment pour des raisons évidentes. Toutefois, la définition de l'opérateur d'affectation pour accepter un argument de type ClassA * est une opération plutôt bizarre. Normalement, l'opérateur d'affectation de ClassA accepterait un argument de type const ClassA & et être invoquée comme

*PtrA = *PtrB;