Class variable in a class of itself C++ - c++

Question

I have a class called Node:
class Node {
private:
Node right;
Node left;
std::string value;
public:
Node(Node right, Node left, std::string value) {
this->right = right;
this->left = left;
this->value = value;
}
};
And I need to declare a private variable of type Node inside the Node class itself.
Is there any way to do this?

Answer 1

You must declare the members as being pointers to Node instances. Especially since you want to be able to set them to NULL, which can only be done with pointers:
class Node {
private:
Node* right;
Node* left;
std::string value;
public:
Node(Node* right, Node* left, std::string value) {
this->right = right;
this->left = left;
this->value = value;
}
};

Answer 2

When you are trying to declare a class with itself as a member like this, you need to use pointers to do so. If you didn't need pointers, then creating one node object would construct two node members, both of which have their own node members which would construct more nodes and so on. By using pointers, you effectively must explicitly link each pointer member to an object in the heap, which prevents an immediate stack overflow error.
class Node {
private:
Node* right;
Node* left;
std::string value;
public:
Node(Node right, Node left, std::string value) {
this.right = new Node(right.data);
this.left = new Node(left.data);
this.value = value;
}
~Node(){ delete left; delete right; }
};
Here's an example of how this might look. This won't compile as-is, but its a representation of the right idea. Make sure to initialze left or right to nullptr unless you explicitly assign it in construction and specify a destructor like in this example. Also don't forget "the big three" if needed.
Note that I changed your shorthand to a dot operator, as in this.right. Your compiler will probably understand what you mean, but the shorthand should only be used when accessing a pointers data, such as in something like right->data. In case you didn't know, right->data actually does the exact same thing as (*right).data. We use a shorthand operator because *right.data would fail because the dot operator has higher precedence than the dereference operator.