1

t.PreorderTraversal(t, &t.getRoot());「ノード」タイプの一時オブジェクトのアドレスを取得中にエラーが発生しました。ルートは 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;
}
4

3 に答える 3

1

この関数は、のメンバーであるオブジェクトのコピーを返しますNodeTree

Node getRoot();

したがって、この行では、直後に破棄されるこのオブジェクトのアドレスを取得しています。

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

残されたポインターは、有効なオブジェクトを指していないため、ダングリング ポインターと呼ばれます。

getRootこのように変更することを検討してください

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

もちろん、Rootこのポインターを使用している間、オブジェクトがスコープ外に出ないようにする必要があります

于 2015-11-01T15:42:43.220 に答える
0

コンパイルエラーはまさに正しいです。あなたは一時的なアドレスを取得しています（これは標準に違反しています）。Tree::getRoot() はクラス Node のコピーを返すので、&t.getRoot() はテンポラリのアドレスです。代わりに getRoot() からポインターを返すつもりだったと思います。この構文は次のようになります。

Node * getRoot();
于 2015-11-01T15:42:28.603 に答える
0

変化する：

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

に：

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

それ以外の場合 -未定義の動作が不正な&t.getRoot()一時オブジェクトのアドレスを返しています。

于 2015-11-01T15:43:08.597 に答える