Q: How to delete the root node in a 1-layer BST I have a simple BST node struct:
struct Node {
    int value;
    Node* left;
    Node* right;
}

Back in C, the constructor would be like:
Node* construct_node(int value){
    Node* node = (Node*) malloc(sizeof(Node)); 
    node->data = value; 
    node->right = NULL; 
    node->left = NULL; 
} 

Making it is easy to delete the root, since it is just another dynamically allocated node.
In C++, however, the constructor doesn't return anything, and the root is the only node that is statically allocated.
Node::Node(const int& value, Node* left, Node* right) {
    this->value = value;
    this->left = left;
    this->right = right;
}

Is there any way to go around this so that deleting the root is possible just like in C, even if the user declares it statically in the main? Or a way to strict the user to declare it only using 'new'? Keeping it 1-layer without adding another class as the tree holding nodes by pointing to the root one.

A: You can simply not define a constructor of this type at all. Just create a default constructor,
Node::Node(){}

And make all members private with getters. This will make this constructor useless.
Now create a function which behaves just like the one in C,
Node* Node::new_node(int val, Node *l, Node *r){
      Node *n = new Node();
      n->left = l;
      n->right = r;
      return n;
}

This will force people to use this constructor only.

A: Okay, I think you have some confusion about pointers between C and C++. They're the same thing. There's nothing at all that keeps you from writing this method in C++:
Node * construct_node(int value) {
    Node * node = new Node(value, nullptr, nullptr);
    return node;
}

At which point, all that really changes in deleting the node is that you use:
delete node;

Instead of:
free(node);

Everything else remains the same. Now, you have to decide what happens when you delete a Node. Do you want destructor that deletes the left and right nodes recursively? Or do you let them potentially get lost? So you're not done.
