C++ C++'；这'；类方法中的指针用法

我将从C到C++移植一个二进制树，将它转换成进程中的一个类。BR> 对于C处理大多数事情的方式，请提前表示歉意
属性包括

T data;
node<T> *left, *right;

所以它们指向同一个左边的物体，但当以不同的方式观察时，该物体持有不同的值，会给出什么

---

附加信息
声明

template <typename T>
class node {
public:
    T data;
    node<T> *left, *right;

    void insert(T data);
    int remove(T target);  // returns success or not
    node<T>* find(T target);
    void print(int mode);  // need overloading since can't use 'this' as default var
    void print(int mode, node<T>* root);

private:
    node<T>* node_new(T data);
    void node_find(T key, node<T>*** target_node_address_handle);
    void node_delete(node<T>** target_address);
};

template <typename T>
node<T>::~node(void) {
    left = NULL;
    right = NULL;
}

模板
类节点{
公众：
T数据；
节点*左，*右；
无效插入（T数据）；
int remove（T目标）；//返回是否成功
节点*查找（T目标）；
void print（int模式）；//需要重载，因为无法将“this”用作默认变量
无效打印（整数模式，节点*根）；
私人：
节点*新节点（T数据）；
无效节点查找（T键，节点***目标节点地址句柄）；
无效节点删除（节点**目标地址）；
};

建造师

template <typename T>
node<T>::node(T rootdata) {
    data = rootdata;
    left = NULL;
    right = NULL;
}

template <typename T>
node<T>::node(const node<T>& anothernode) {
    data = anothernode.data;
    if(anothernode.left) *left = *anothernode.left;
    else left = NULL;

    if(anothernode.right) *right = *anothernode.right;
    else right = NULL;
}

模板
node:：node（T rootdata）{
数据=根数据；
左=空；
右=空；
}

查找由insert和delete共享的方法

template <typename T>
void node<T>::node_find(T key, node<T>*** target_node_address_handle) {
    node<T>* current = this;
    while(current) {
         if (typeid(key) == typeid(current->data)) {
              if (key == current->data) break;
              else if (key < current->data) current = current->left;
              else current = current->right;
         }
    }
    // if loop exited without breaking, will insert into empty NULL position
    *target_node_address_handle = &current;
}

模板
无效节点：：节点查找（T键，节点***目标节点地址句柄）{
节点*当前=此；
while（当前）{
if（typeid（键）=typeid（当前->数据））{
如果（键==当前->数据）中断；
否则，如果（键<当前->数据）当前=当前->左侧；
否则当前=当前->右侧；
}
}
//如果循环退出而不中断，则将插入空的空位置
*目标节点地址句柄=¤t；
}

我的插入不起作用，但我不确定这是node\u find还是node\u insert中的问题

template <typename T>
void node<T>::insert(T data) {
    node<T>** target_node_address;
    node_find(data, &target_node_address);  
    // target_node_address should now point to one of root's decedents

    if (!(*target_node_address))   // nothing at target node as expected
        *target_node_address = node_new(data);   
        // node_new returns pointer to node
}

模板
void节点：：插入（T数据）{
节点**目标节点地址；
节点查找（数据和目标节点地址）；
//目标节点地址现在应该指向root的一个死者
if（！（*target\u node\u address））//目标节点上没有预期的内容
*目标节点地址=节点新（数据）；
//node\u new返回指向节点的指针
}

---

编辑
复制构造函数

template <typename T>
node<T>::node(T rootdata) {
    data = rootdata;
    left = NULL;
    right = NULL;
}

template <typename T>
node<T>::node(const node<T>& anothernode) {
    data = anothernode.data;
    if(anothernode.left) *left = *anothernode.left;
    else left = NULL;

    if(anothernode.right) *right = *anothernode.right;
    else right = NULL;
}

模板
节点：：节点（常量节点和另一个节点）{
数据=另一个节点。数据；
if（anothernode.left）*left=*anothernode.left；
else left=NULL；
if（anothernode.right）*right=*anothernode.right；
else-right=NULL；
}

析构函数（都在声明中添加）

模板
节点：：~节点（无效）{
左=空；
右=空；
}

---

有趣的是，在我显式地将这些添加到…之前，它编译得很好。

新节点解决了问题，插入更改为：

template <typename T>
node<T>* node<T>::node_new(T data) {
    node<T>* newnode = new node<T>(data);
    return newnode;
}

template <typename T>
void node<T>::node_find(T key, node<T>*** target_node_address_handle) {
    // find node matched by key, or NULL pointer in correct location
    // give node pointer address back
    node<T>* root = this;
    node<T>** target_address = &root;
    while(*target_address) {
        node<T>* current = *target_address;
        if(typeid(key) == typeid(current->data)) {  
            //  assume comparison operator exists
            if(key == current->data)
                break;
            else if(key < current->data)
                target_address = &current->left;
            else
                target_address = &current->right;
        }
    }
    // if loop exited without breaking, will insert into an empty NULL position
    // else loop exited by matching/breaking, will delete non-NULL node
    *target_node_address_handle = target_address;
}

模板
node*node:：node_new（T数据）{
node*newnode=新节点（数据）；
返回newnode；
}
模板
无效节点：：节点查找（T键，节点***目标节点地址句柄）{
//在正确位置查找由键或空指针匹配的节点
//返回节点指针地址
node*root=this；
节点**目标地址=&root；
while（*目标地址）{
节点*当前=*目标地址；
如果（typeid（key）=typeid（当前->数据））{
//假设存在比较运算符
如果（键==当前->数据）
打破
否则如果（键<当前->数据）
目标地址=&当前->左侧；
其他的
目标地址=&当前->右侧；
}
}
//如果循环在未中断的情况下退出，则将插入空的NULL位置
//else循环通过匹配/中断退出，将删除非空节点
*目标\节点\地址\句柄=目标\地址；
}

---

问题是我将

¤t

返回给

*target\u node\u address\u handle

，这将是指向NULL的指针的地址，而不是指向NULL的指针的指针，我可以更改它。

节点的声明是什么？您的代码似乎不符合要求。

节点是否有复制构造函数和析构函数？行
node newnode=node（5）意味着创建一个临时对象，复制它，然后调用它的析构函数。如果您没有正确的复制（或移动）构造函数，这可能意味着未定义的行为。哦，好吧，我将看看当我在您的行中添加这些构造函数时会发生什么：
cout copy并粘贴到下面（我之前遗漏了std名称空间）
std:：cout