Класс Бинарное дерево

#include <list>
#include <iostream>
 
template<typename T>
struct tree_t {
    T data;
    tree_t(const T& value)
        : data{value} {
    }
    tree_t& emplace_left(const T& value) {
        left.clear();
        left.emplace_back(value);
        return left.front();
    }
    tree_t& emplace_right(const T& value) {
        right.clear();
        right.emplace_back(value);
        return right.front();
    }
    void clear_left() {
        left.clear();
    }
    void clear_right() {
        right.clear();
    }
    bool has_left() const {
        return !left.empty();
    }
    bool has_right() const {
        return !right.empty();
    }
    const tree_t& get_left() const {
        return left.front();
    }
    const tree_t& get_right() const {
        return right.front();
    }
    tree_t& get_left() {
        return left.front();
    }
    tree_t& get_right() {
        return right.front();
    }
private:
    std::list<tree_t> left;
    std::list<tree_t> right;
};
 
template<typename T>
void print_tree(const tree_t<T>& tree, size_t spacing = 0) {
    std::cout << tree.data << std::endl;
    if(tree.has_left()) {
        std::cout << std::string(spacing + 1, ' ') << "L: ";
        print_tree(tree.get_left(), spacing + 1);
    }
    if(tree.has_right()) {
        std::cout << std::string(spacing + 1, ' ') << "R: ";
        print_tree(tree.get_right(), spacing + 1);
    }
}
 
int main(int argc, char *argv[]) {
    tree_t<int> tree{10};
    auto& l1 = tree.emplace_left(5);
    l1.emplace_left(2);
    l1.emplace_right(6);
    auto& r1 = tree.emplace_right(15);
    r1.emplace_left(12);
    r1.emplace_right(17);
    print_tree(tree);
    tree.clear_left();
    print_tree(tree);
 }

#include <iostream>
using namespace std;
template<typename D>
struct TNode{
    D     data{};
    TNode* left  = nullptr;
    TNode* right = nullptr;
    TNode() = default;
    TNode(D data):data{data}{};
    ~TNode(){
        if (left) delete left;
        if (right) delete right;
    };
};
template<typename T>
class MyBTree{
private:
    using Node = TNode<T>;
    Node* root      = nullptr;   // корень дерева
public:
    Node* SetRoot(const T& data){
        if (root == nullptr)
            root = new Node(data);
        return root;
    };
    void Delete(Node * to, bool left){
        if (left){
            delete to->left;
            to->left = nullptr;
        }else
        if (left){
            delete to->right;
            to->right = nullptr;
        }
    }
    Node * Add(Node * to, const T& data, bool left){
        if ( to )
        {
            if (left){
                if (!(to->left))
                   return to->left = new Node(data);
            }
            else
                if (!(to->right))
                   return to->right = new Node(data);
        }
        return to;
    }
    void Add(Node * to, const T& left_data, const T& right_data){
        if (to){
            Add(to, left_data, true);
            Add(to, right_data, false);
        }
    }   
    Node * Root() const{
        return root;
    };
    void SimplePrint() const{
        SimplePrint(root);
    }
    void SimplePrint(const Node * curr, unsigned level=0) const{
        if (curr) {
            SimplePrint(curr->left, level + 1);
            for (unsigned i = 0; i < level; i++)
                cout << "    ";
            cout << curr->data << endl;
            SimplePrint(curr->right, level + 1);
        }
    };
   ~MyBTree(){
       delete root;
   }
};
 
 
int main()
{
    MyBTree<int> tree;
    struct auto_counter{
        int c{};
        operator int(){return ++c;};
    };
    auto_counter counter;
    using Node = TNode<int>;
    Node * n1, * n2, * n3;
    // <<-- Построение дерева -->>//
    n1 = tree.SetRoot(counter);
    n2 = tree.Add(n1, counter, true);
    tree.Add(n2, counter, false);
    n1 = tree.Add(tree.Root(), counter, false);
    n2 = tree.Add(n1, counter, true);
    n3 = tree.Add(n2, counter, true);
    tree.Add(n3, counter, true);
 
    tree.Add(n2, counter, counter);
    tree.Add(n1, counter, false);
    tree.Add(n3, counter, counter);
    // <<-- Дерево построенно -->>//
    cout << "Tree : " << endl;
    cout << "===============================" << endl;
    tree.SimplePrint();
    cout << "===============================" << endl;
    cout << "Delete some nodes(tree)." << endl;
    tree.Delete(n1, true);
    tree.Delete(n1, false);
    cout << "Tree : " << endl;
    cout << "===============================" << endl;
    tree.SimplePrint();
    cout << "===============================" << endl;
}