C++ 在结构中创建智能指针？

我正在使用结构对二叉树中的节点进行建模。在结构中，我试图有一个指向左和右子对象的指针

问题是，由于我创建结构的方式，我一直遇到堆栈溢出。我处理智能指针的方式似乎是不断地在堆栈上分配内存

当我在main中创建

根目录时，会特别抛出异常

我不熟悉智能指针（我一直在使用原始指针，最近我发现这在C++中是一种不好的做法），我尝试自己解决这个问题，但运气不好

有人能批评我的结构/智能指针的使用吗？非常感谢

#include <iostream> 
#include <memory> 

//Node struct 
struct Node
{
    int data;
    std::unique_ptr<Node> left;
    std::unique_ptr<Node> right;

    Node(int data) {
        this->data = data;
        this->left = std::make_unique<Node>(NULL);
        this->right = std::make_unique<Node>(NULL); 
    }

};

//insert Node into binary search tree
void insert(int data, std::unique_ptr<Node>& root)
{
    if (root == NULL)
    {
        root = std::make_unique<Node>(data);
    }
    else {
        if (root->data > data)
        {
            insert(data, root->left);
        }
        else {
            insert(data, root->right);
        }
    }
}

//In Order tree traversal 
void inOrderTraversal(std::unique_ptr<Node>& root)
{
    if (root == NULL) return; 

    inOrderTraversal(root->left); 

    std::cout << root->data << std::endl; 

    inOrderTraversal(root->right); 
}

int main()
{
    //Initialize root to NULL
    std::unique_ptr<Node> root = std::make_unique<Node>(NULL);


    insert(20, root); 
    insert(50, root);
    insert(30, root);
    insert(5, root);
    insert(6, root);
    insert(99, root);
    insert(77, root);
    insert(56, root);
    insert(32, root);
    inOrderTraversal(root); 

    return 0; 
}

#包括
#包括
//节点结构
结构体类型
{
int数据；
std：：唯一左上角；
std：：唯一的ptr权限；
节点（int数据）{
这->数据=数据；
this->left=std:：make_unique（NULL）；
this->right=std:：make_unique（NULL）；
}
};
//将节点插入到二叉搜索树中
void insert（int数据，std:：unique\u ptr和root）
{
if（root==NULL）
{
root=std：：使_唯一（数据）；
}
否则{
如果（根->数据>数据）
{
插入（数据，根->左）；
}
否则{
插入（数据，根->右）；
}
}
}
//顺序树遍历
void inOrderTraversal（std:：unique_ptr&root）
{
if（root==NULL）返回；
inOrderTraversal（根->左）；
std：：cout数据权限）；
}
int main（）
{
//将root初始化为NULL
std:：unique_ptr root=std:：make_unique（NULL）；
插入（20，根部）；
插入（50，根）；
插入（30，根部）；
插入（5，根部）；
插入（6，根部）；
插入（99，根）；
插入（77，根）；
插入（56，根部）；
插入（32，根）；
inOrderTraversal（根）；
返回0；
}
用nullptr替换所有NULL，不要使用std:：make_unique（NULL）

Node:：Node（int数据）{
这->数据=数据；
此->左=空PTR；
此->右=nullptr；
}
int main（）
{
//将root初始化为NULL
std:：unique_ptr root=nullptr；
//其他代码。。
}
std:：make_unique
使用参数转发
节点
构造函数

< C和C++ >代码> null <代码>通常只是一个宏，用于<代码> 0 < /C> > < /P>
因此，当您调用
std:：make_unique（NULL）时
您正在使用
data=0
初始化
节点

然后递归调用
This->left=std:：make_unique（NULL），最终导致无限递归和堆栈溢出

要解决此问题，可以指定
std:：unique\u ptr left=NULL

我还建议使用
nullptr
代替
NULL
，因为它是类型安全的。只需在代码上用
nullptr
替换
NULL
，就会出现编译器错误，帮助您解决问题

错误：“节点”的初始化没有匹配的构造函数

使用
nullptr
初始化与默认构造函数没有区别，因此
this->left
和
this->right
根本不需要在构造函数主体中。并且可以使用
std:：unique\u ptr root创建
root

Node::Node(int data) {
    this->data = data;
    this->left = nullptr;
    this->right = nullptr;
}



int main()
{
    //Initialize root to NULL
    std::unique_ptr<Node> root = nullptr;

        // other codes ..
}