使用指針成員變量重載類中的+運算符

Question

我有一個非常簡單的類。它有一個指針成員變量。我想重載+運算符。但是，它不起作用！這裏是我的代碼：

#include <iostream> 
using namespace std; 


template <typename T> 
struct Node{ 
    Node *next; 
    T data; 
}; 

template <typename T> 
class stack{ 
protected: 
    Node <T> *head; 

public: 
    stack(); 
    ~stack(); 
    bool push(T); 
    stack <T> operator+ (stack <T>); 

}; 

template <typename T> 
stack<T>::stack(){ 
    head = NULL; 
} 

template <typename T> 
stack <T>::~stack(){ 
    Node <T> *temp; 

    while(head){ 
     temp = head; 
     head = head->next; 
     delete temp; 
    } 
} 

template <typename T> 
bool stack <T>::push(T data){ 
    Node <T> *newElem = new Node <T>; 
    if (!newElem) return false; 

    newElem->next = head; 
    newElem->data = data; 
    head = newElem; 
    return true; 
} 

template <typename T> 
stack <T> stack<T>::operator+ (stack <T> stack1){ 
    stack <T> result; 
    Node <T> *temp = head; 

    while (temp) { 
     result.push(temp->data); 
     temp = temp->next; 
    } 

    temp = stack1.head; 
    while (temp) { 
     result.push(temp->data); 
     temp = temp->next; 
    } 

    return result; 
} 

int main(){ 
    stack <int> myStack1, myStack2, myStack3; 

    myStack1.push (1); 
    myStack1.push (2); 

    myStack2.push (3); 
    myStack2.push (4); 

    myStack3 = myStack1 + myStack2; // here at runtime myStack3 is not the result of myStack1 + myStack2. 
    return 0; 
} 

你能幫我一下嗎？ 請注意，這只是用於練習。

非常感謝。

Answer 1

你的問題是，你正在創建的操作員的右手側的副本。簽名應該是：

template <typename T> 
stack <T> stack<T>::operator+ (const stack <T>& stack1) { ... } 

，這樣你只引用stack1，而不是複製它。

這將解決你眼前的問題，但長期來看，你也想實現一個正確的拷貝構造爲stack的所有副本都會當前損壞記憶，因爲他們鏈接相同的元素和destrutor會刪除它們，其他stack然後仍然引用刪除的元素。

這就是爲什麼你看到「結果」具有預期值，名爲stack1的副本尚未刪除。但是當operator+返回時，它將刪除stack1，因此stack1的所有元素都將被刪除。並非所有複製到引用stack1中的元素的結果的指針均無效。這就是爲什麼stack3在通話後顯示中斷。

另請參閱rule of three，閱讀答案中的「管理資源」部分。

---

更新：這是不夠的，你還可以指派的operator+結果，再而三的規則適用，你沒有一個正確的賦值操作爲好。您可能需要將這些添加到您的課程中：

template <typename T> 
stack<T>::stack(const stack<T>& src) 
{ 
    // this will reverse the src, I'll leave it to you to fix the order! 
    head = NULL; 
    Node<T>* tmp = src->head; 
    while(tmp) { 
     push(tmp->data); 
     tmp = tmp->next; 
    } 
} 

template <typename T> 
stack<T>& stack<T>::operator=(stack<T> src) // copy the argument is OK here! 
{ 
    stack old; 
    old->head = head; 
    head = src->head; 
    src->head = NULL; 
} 

既然您正在學習，那麼以上是一個很好的起點。現在，您可以

• 的方式實現的拷貝構造函數，它並沒有扭轉元素
• 瞭解賦值運算符的作品究竟是如何的順序。我使用了一個不尋常的實現，但是一旦你瞭解它，你就學到了很多關於對象生命週期的知識:)

Answer 2

你宣告類聲明別的東西，你在定義中寫道：+=，而不是+：

stack <T> operator+ (stack <T>); 
       ^

stack <T> stack<T>::operator+= (stack <T> stack1){ 
          ^^