我正在C++中创建一个二叉树，在节点类内部使用智能指针时遇到了一些问题。当使用普通指针时，一切都很好，但使用智能指针时，它就是不起作用。我认为问题在于插入方法中的这一行：
'''
binaryNode* node = this; // This is working
std::shared_ptr<binaryNode> node {this}; // This throws "double free or corruption" error
std::shared_ptr<binaryNode> node = shared_from_this (); // This throws "bad weak ptr error", I am correctly inheriting from enable_shared_from_this
'''
如何使用智能指针复制binaryNode* node = this;？我甚至试着经常成功地使用public std::enable_shared_from_this<binaryNode>。谢谢你的帮助！
编辑：我会试着更好地解释自己。这是二进制搜索树的insert()函数，如下所示(这是.cpp文件(：
'''
#include "binarynode.h"
binaryNode::binaryNode(int value){
this->value = value;
this->right = nullptr;
this->left = nullptr;
}
void binaryNode::insert(int value){
binaryNode* node = this;
while(true){
if(value > node->value){
if(node->right != nullptr){
node = node->right;
}else{
node->right = new binaryNode(value);
break;
}
}else if(value < node->value){
if(node->left != nullptr){
node = node->left;
}else{
node->left = new binaryNode(value);
break;
}
}else{
return;
}
}
我如何使用智能指针复制它？
编辑2：这是我的.h文件：
'''
#ifndef BINARYNODE_H
#define BINARYNODE_H
class binaryNode
{
public:
int value;
binaryNode(int value);
binaryNode* right;
binaryNode* left;
void insert(int value);
};
#endif // BINARYNODE_H
这是主文件：
#include <iostream>
#include "binarynode.h"
using namespace std;
void printTree(binaryNode* node){
if(node == nullptr) return;
cout << node->value << endl;
printTree(node->left);
printTree(node->right);
}
int main(){
binaryNode* bn = new binaryNode(9);
bn->insert(4);
bn->insert(20);
bn->insert(1);
bn->insert(6);
bn->insert(15);
bn->insert(170);
printTree(bn);
return 0;
}
您不需要使用shared_ptr<gt；。
实际上，智能指针是用来"解决"对象的所有权的，因此，当对象只有一个所有者时，unique_ptr<gt；应该使用，并且当共享所有权时，将使用shared_ptr。在您的情况下，所有权是明确的，每个节点都拥有其左右成员，因此可以使用unique_ptr。
对于树遍历问题，不要乱用智能指针，因为你没有请求任何所有权，只是查看值，因此原始指针是可以的
所以你可能会得到这样的东西：
#include <memory>
#include <iostream>
struct binaryNode {
binaryNode(int value) : value(value) {}
void insert(int value);
int value = 0;
std::unique_ptr<binaryNode> right;
std::unique_ptr<binaryNode> left;
};
void binaryNode::insert(int value){
binaryNode* node = this;
while(true){
if(value > node->value){
if(node->right != nullptr){
node = node->right.get();
}else{
node->right = std::make_unique<binaryNode>(value);
break;
}
}else if(value < node->value){
if(node->left != nullptr){
node = node->left.get();
}else{
node->left = std::make_unique<binaryNode>(value);
break;
}
}else{
return;
}
}
}
void printTree(const binaryNode &node){
std::cout << node.value << std::endl;
if (node.left)
printTree(*node.left);
if (node.right)
printTree(*node.right);
}
int main(){
auto bn = std::make_unique<binaryNode>(9);
bn->insert(4);
bn->insert(20);
bn->insert(1);
bn->insert(6);
bn->insert(15);
bn->insert(170);
printTree(*bn);
return 0;
}
您可能会注意到，打印不需要使用指针，它可以在引用时工作。
- 不能多次直接将同一个原始指针转换为共享指针，因为这样会有几个互不了解的所有者，每个所有者都认为自己可以完全控制对象。这就是
std::shared_ptr<binaryNode> node {this}为您提供双重删除的原因 - 您也不能使用
shared_from_this，除非至少有一个共享指针已经指向您的对象。这就是std::shared_ptr<binaryNode> node = shared_from_this ()不起作用的原因
如果您想要共享指针，请将它们全部共享。例如：
// binaryNode* bn = new binaryNode(9); <-- nope!
auto bn = std::make_shared<binaryNode>(9);
// binaryNode* node = this; <-- nope!
std::shared_ptr<binaryNode> node = shared_from_this();
不过，我不建议在这里使用共享指针。唯一指针更合适。
C++向量可以用于支持递归数据结构。使用智能ptr要简单得多。Basicly在你的节点存储向量子作为一个成员。
#include <vector>
using std::vector;
struct Node {
Node() = default;
Node(const Node &) = delete;
Node(Node &&) = default;
vector<Node> children;
};
int main()
{
Node root;
root.children.push_back(Node());
root.children.push_back(Node());
root.children[0].children.push_back(Node());
}