L'opérateur d'assignation surchargé n'est pas appelé

Question

J'ai écrit un opérateur d'affectation surchargé de classe perform en copiant toutes les valeurs de variables. Ex: dans Exp.cpp

class perform 
{ 
    LOG *ptr; 
int a; 
//constructor 
//destructor 
perform operator=(const perform & rhs){ 

    ptr = rhs.ptr; a=rhs.s; 
return * this;} 
}; 

Dans une autre classe output, j'ai déclaré un pointeur pour abc.

perform * ptr = StatCol::CreateCol(frm); 
abc = ptr; //this line should invoke assignment overloaded. 
      //but in my case it's not invoked. 

Answer 1

En supposant abc est un objet Exécuter, vous devez déréférencer le pointeur vous assignez:

abc = * ptr; 

Si abc est lui-même un pointeur, alors vous ne pouvez pas faire ce que vous demandez - vous ne peut pas surcharger l'affectation lorsque le LHS est un pointeur. Vous devez déréférencer les pointeurs:

* abc = * ptr; 

Answer 2

En outre, il est plus sûr de revenir par référence évitant ainsi un constructeur de copie appelée.

const perform& operator=(const perform & rhs){ 

    if (this != &rhs) 
    { 
     ptr = rhs.ptr; a=rhs.s; 
    } 
    return * this; 
    } 

Answer 3

Custom assignment operator works only with user defined types so do like this: 

perform p1,p2; 
p1 = p2; 
perform *p = &p2; 
p1 = *p; 


You can't override assignment of built in types(int , char etc.). 

perform *p1,*p2; 
p1 = p2; 

It simply copies the address of p2 to p1. 

Answer 4

Dans l'exemple de code que vous assignez des pointeurs, donc il n'y a aucune chance que vous pourriez jamais appeler l'opérateur d'affectation sans déréférencer le pointeur.

Et en utilisant cette conception, le risque de faire des copies superficielles est énorme. De plus, la signature de l'opérateur d'affectation C++ est: 'Effectuer & operator = (...)' comme indiqué dans la norme. Il doit renvoyer une référence au même objet pour que le compilateur le considère comme prévu.

more about assignment operator....