以「節點」類型的臨時對象的地址爲例

Question

t.PreorderTraversal(t, &t.getRoot());該錯誤正在接受「節點」類型的臨時對象的地址。 Root是一個Node類對象。函數PreoderTraversal將Node對象作爲一個點，所以我給出Node對象的地址併發生錯誤。這不是正確的做法嗎？

class NodeList; 

class Node { 
private: 
    Node* parent; 
    int elem; 
    NodeList* children; 
    Node *next; 
    Node *prev; 

}; 

class NodeList { 
public: 
    NodeList(); 
    void addNodeAtRank(int, int); 
private: 
    Node* header; 
    Node* tailer; 
}; 

class Tree { 
private: 
    int n; 
    Node root; 
public: 
    Tree(); 
    void addNode(Tree &t, int, int, int); 
    void PreorderTraversal(const Tree& t, Node* p); 
    void PostorderTraversal(const Tree& t, Node* p); 
    void printXYofNode(const Tree& t, int nodeNumber); 
    Node getRoot(); 
    Node* getNodeByElem(Node& n, int); 
}; 

Node::Node() { 

    children = nullptr; 
    parent = nullptr; 
    elem = 0; 
    next = nullptr; 
    prev = nullptr; 

} 

NodeList::NodeList() { 

    header = new Node(); 
    tailer = new Node(); 

    header->next = tailer; 
    tailer->prev = header; 
} 

void NodeList::addNodeAtRank(int rank, int e) { 

    Node *v = new Node(); 
    v->elem = e; 

    int count = 1; 
    Node *NodeAtRank = header->next; 

    while (count != rank) { 
     NodeAtRank = NodeAtRank->next; 
     count++; 
    } 

    v->next = NodeAtRank; 
    v->prev = NodeAtRank->prev; 
    NodeAtRank->prev = v; 
    NodeAtRank->prev->next = v; 

} 

bool NodeList::empty() const { 
    return header->next == tailer; 
} 

Tree::Tree() { 

    n = 0; 
    //root = Node(); 
} 

void Tree::addNode(Tree& t, int NodeElement, int ParentNode, int SiblingOrder) { 

    //Node *treeNode = new Node(); 

    if (t.empty() && ParentNode == -1 && SiblingOrder == -1) { 
     t.root = Node(); 
     t.root.elem = NodeElement; 
     t.root.children = new NodeList(); 
    } else { 

     Node* nodeParent = t.getNodeByElem(t.root, ParentNode); 

     NodeList *childrenNodelist = nodeParent->children; 
     childrenNodelist->addNodeAtRank(SiblingOrder, NodeElement); 

     nodeParent->children = childrenNodelist; 
    } 

    n++; 
} 

Node* Tree::getNodeByElem(Node& root, int nodeElem) { 

    if (root.elem == nodeElem) 
     return &root; 
    else { 
     NodeList *rootChildren = root.children; 

     Node *head = rootChildren->header; 

     while (head->next != rootChildren->tailer) { 

      if (!head->next->isExternal()) 
       return getNodeByElem(*(head->next), nodeElem); 
      else { 
       if (head->next->elem == nodeElem) 
        return head->next; 

       head = head->next; 
      } 
     } 

     return new Node(); 
    } 
} 

void Tree::PreorderTraversal(const Tree& t, Node* p) { 

    cout << p->elem; 
    NodeList *mychildren = p->children; 
    Node *traversal = mychildren->header->next; 

    while (traversal != mychildren->tailer) { 
     cout << " "; 
     PreorderTraversal(t, traversal->next); 
     traversal = traversal->next; 
    } 

} 

void Tree::PostorderTraversal(const Tree& t, Node* p) { 

    NodeList *mychildren = p->children; 
    Node *traversal = mychildren->header->next; 

    while (traversal != mychildren->tailer) { 
     PreorderTraversal(t, traversal); 
     traversal = traversal->next; 
    } 
    cout << p->elem; 
} 

bool Tree::empty() const { 
    return n == 0; 
} 

int Tree::size() const { 
    return n; 
} 

Node Tree::getRoot() { 
    return root; 
} 

int main(int argc, const char * argv[]) { 

    char Type = NULL; 
    int nodeNumber = 0; 
    int nodeParent = 0; 
    int nodeOrderInSibling = 0; 

    Tree t = Tree(); 
    cin >> Type; 
    while (Type != 'Q') { 
     if (Type == 'I') { 
      cin >> nodeNumber >> nodeParent >> nodeOrderInSibling; 
      t.addNode(t, nodeNumber, nodeParent, nodeOrderInSibling); 
     } else if (Type == 'P') { 
      t.PreorderTraversal(t, &t.getRoot()); 
     } else if (Type == 'T') { 
      t.PostorderTraversal(t, &t.getRoot()); 
     } else if (Type == 'C') { 
      cin >> nodeNumber; 
      t.printXYofNode(t, nodeNumber); 
     } else { 
      cout << "Wrong input type!!!" << endl; 
     } 

     cin >> Type; 
    } 

    return 0; 
} 

Answer 1

編譯器錯誤是完全正確的。你是取臨時地址（這是違反標準的）。 Tree :: getRoot（）返回一個副本的類節點，所以& t.getRoot（）是臨時地址。我認爲你的意思是從getRoot（）返回一個指針。其語法是：

Node * getRoot(); 

Answer 2

這個函數返回一個複製的Node對象是Tree

Node getRoot(); 

所以在這行你得到這個對象的地址成員之後會被丟棄。

t.PreorderTraversal(t, &t.getRoot()); 

您留下的指針稱爲懸空指針，因爲它沒有指向有效的對象。

考慮修改getRoot這樣

Node* Tree::getRoot() { 
    return &root; 
} 

當然，你必須確保在您使用該指針

Answer 3

更改Root對象不出去範圍：

Node Tree::getRoot() { 
    return root; 
} 

至：

Node& Tree::getRoot() { 
    return root; 
} 

否則&t.getRoot() - 正在返回的臨時對象的地址是 未定義的行爲 非法。