为二叉搜索树创建一个新节点

Question

For a school project I am trying to make a binary search tree at the same time we are supposed to learn how to use 'friendship' in classes. The errors I get while compiling are: [I put comments in code where the errors originate from for clarity] (Keep in mind I am not allowed to nest Node in the BST class they are both supposed to be in separate files and classes for the sake of this programming assignment)

BST.cpp: In member function `void BST::insert(std::string, std::string)':
BST.cpp:51: error: non-lvalue in assignment
BST.cpp:58: error: non-lvalue in assignment
BST.cpp:62: error: non-lvalue in assignment
makefile.txt:9: recipe for target `BST.o' failed
make: *** [BST.o] Error 1

I tried using the 'new' operator in BST.cpp and Node.cpp but I still can't get rid of those error messages. I believe that I might be missing a few syntax that is making the compiler not like it. Here are the files used in this assignment: (Note some functions arent used yet since I have not gotten that far in the project.) Node.h

#ifndef NODE_H_INCLUDED
#define NODE_H_INCLUDED

#include <iostream>
#include <string>

using namespace std;

class BST;
class Node
{
public:
    Node(string key, string data)
    {m_key = key; m_data = data;}
    ~Node();
    static string get_key(); //takes in ptr to node and returns its key
    static string get_data(); //takes in ptr to node and returns its data
    static Node* get_left(); //takes in ptr to node and returns its left child pointer
    static Node* get_right(); //takes in ptr to node and returns its right child pointer
    static Node* get_parent(); //takjes in ptr to node and returns its parent pointer
    static Node* create_node(string key, string data);
    static void destroy_node();

private:
    string m_key;
    string m_data;
    Node *m_left;
    Node *m_right;
    Node *m_parent;
};


#endif // NODE_H_INCLUDED

Node.cpp

#include "Node.h"

static string Node::get_key()
{
    return m_key;
}
static string Node::get_data()
{
    return m_data;
}
static Node* Node::get_left()
{
    return m_left;
}
static Node* Node::get_right()
{
    return m_right;
}
static Node* Node::get_parent()
{
    return m_parent;
}
static Node* Node::create_node(string key, string data)
{
    Node* ptr = new Node(key, data);
    ptr->m_left = NULL;
    ptr->m_right = NULL;
    ptr->m_parent = NULL;
    return ptr;
}

My intent so far is to have Node::create_Node to make a new node, Nullify all the pointers, and lastly pass the pointer of the node back to BST.cpp so the pointers can be modified and inserted into the tree. Below are BST.cpp and BST.h (I put comments where the errors occur for your clarity) BST.h:

#ifndef BST_H_INCLUDED
#define BST_H_INCLUDED

#include <iostream>
#include <string>

using namespace std;

class BST
{
public:
    BST()
    {m_root = NULL;}
    ~BST();
    void insert(string key, string data);
    void find(string key);
    void remove(string key, string data);
    void print();
    friend class Node;
private:
    Node* m_root;

};

#endif // BST_H_INCLUDED

Finally, BST.cpp (where the errors occur) The errors happen when I attempt to modify the pointers of z (z is a pointer the brand new node that was just created) including its m_left, m_right and m_parent.

#include "BST.h"
#include "Node.h"

void BST::insert(string key, string data)
{
    Node* x = m_root;
    Node* y = NULL;
    Node* z = Node::create_node(key, data);
    while(x != NULL)
    {
        y = x;
        if(key < x->get_key())
        {
            x = x->get_left();
        }
        else
        {
            x = x->get_right();
        }
    }
    z->get_parent() = y; //error: non-lvalue in assignment
    if(y == NULL)
    {
        m_root = z;
    }
    else if(z->get_key() < y->get_key())
    {
        y->get_left() = z; //error: non-lvalue in assignment
    }
    else
    {
        y->get_right() = z; //error: non-lvalue in assignment
    }
}

Answer 1

If you want to use the return of get_left() etc as a target for an assignment then you must return a reference.

The bigger error however is that you've made all those methods static for some reason. That's not going to work either.

Node*& Node::get_left()
{
    return m_left;
}
Node*& Node::get_right()
{
    return m_right;
}
Node*& Node::get_parent()
{
    return m_parent;
}

However since the point is to learn how to use friendship, you should probably just delete these methods and declare BST as a friend of Node and have BST access these fields directly. That seems to be the point of the exercise.