C++ - Fonction de surcharge d'opérateur de pile de liste chaînée

Question

Je travaille actuellement sur une pile qui implémente une liste chaînée. J'ai un problème quand il s'agit de surcharger l'opérateur "=". Je suis très désemparé quant à ce qu'il faut faire. Si quelqu'un pouvait me pointer dans une bonne direction, ce serait génial.

//operator overload 
template <class S> 
const Stack<S>::operator=(const Stack& s) 
{ 

    if (s.isEmpty()) 
     theFront = theTop = 0 
    else 
    { 
     NodePointer temp = q->theFront; 

     while(temp != 0) 
     { 
      push(temp->data); 
      temp = temp->next; 
     } 
    } 

    return *this; 
} 

Je reçois également cette erreur: Stack, std :: allocateur>> :: :: Noeud Noeud (std :: basic_string, std :: allocateur>) » référencé à partir de C: \ Users \ JOHNNY \ DESKTOP \ STACK \ INFIX_TO_RPN.OBJ

Est-ce que cela peut être corrigé par ma fonction de surcharge de l'opérateur?

Answer 1

Vous devez vider la pile en cours avant d'y insérer des données. Vous devriez ajouter une fonction removeAll, et l'appeler en haut de l'affectation (après une vérification de l'auto-affectation, ce qui est également une bonne idée). Sinon, cela semble correct. Ainsi, le résultat final serait:

//operator overload 
template <class S> 
const Stack<S>::operator=(const Stack& s) 
{ 
    // Check for self assignment 
    if (&s==this) 
     return *this; 

    // Clear the current stack 
    removeAll(); 

    // Copy all data from stack s 
    if (!s.isEmpty()) 
    { 
     NodePointer temp = q->theFront; 

     while(temp != 0) 
     { 
      push(temp->data); 
      temp = temp->next; 
     } 
    } 

    return *this; 
} 

Voici une fonction removeAll exemple:

template <class S> 
void Stack<S>::removeAll()  
{ 
    while (s.theFront) 
    { 
     NodePointer p = s.theFront; 

     s.theFront = s.theFront->next; 
     delete p; 
    } 

    s.theTop = s.theFront; 
} 

Answer 2

Au lieu de mettre en œuvre manuellement l'opérateur d'affectation de copie pour votre classe, utilisez the copy-and-swap idiom.

Une fois que vous avez mis en place une fonction swap() pour votre classe (l'article auquel je lié ci-dessus donne une excellente description de la façon de le faire), la surcharge operator= devient court et simple:

Stack& operator=(Stack rhs) 
{ 
    swap(rhs); 
    return *this; 
}