Реализация древовидной структуры данных - Узел

Question

Могу ли я попросить вас просмотреть мой код и дать мне несколько советов, что я могу сделать лучше в своей реализации?Я хотел бы, чтобы вы судили мое правило пяти.Я пытался придерживаться хороших стандартов кодирования C ++.

У меня есть несколько проблем:

1. Я запутался в выпуске данных из вектора.Должен ли я позвонить clear() или поменять его местами с пустым вектором, как я сделал в своем коде ниже.

Как работает std::move().После вызова std::move(node) я все еще должен удалить все элементы узла или переместить это для меня?

Заголовочный файл для узла

template <typename V>
class Node
{
private:
    bool visited;
    V value;
    std::vector<Node*> children;
    V time;

public:
    Node(V value,V time);
    Node(const Node<V> &node1);
    Node( Node<V> && node1);
    Node();
    ~Node();
    /////////////////////
    Node& operator=(const Node &n1);
    Node& operator=(Node&& other);
     // more code....
};

Cpp файл для узла

template <typename V>
Node<V>::Node()
        : visited(false) , time(0) , value(0)
{
    children.clear();
}

template <typename V>
Node<V>::Node(V value,V time)
        : value(value) , time(time) , visited(false)
{
    children.clear();
}

template <typename V>
Node<V>::~Node()
{
    children.clear();
    std::vector<Node<V>*>Vec_temp;
    children.swap(Vec_temp);
    value = 0;
    time = 0;
    visited = false;
}

template <typename V>
Node<V>::Node(const Node<V>&node)
{
    value = node.get_value();
    children = node.children;
    time = node.get_time();
    visited = node.was_visited();
}

template <typename V>
Node<V>::Node(Node<V> &&node)
    : value(std::move(node.value)) , time(std::move(node.time)) , visited(std::move(node.visited)) , children(std::move(node.children))
{
    std::vector<Node<V>*>temporary;
    node.children = temporary;
    node.visited = false;
    node.value = 0;
    node.time = 0;
}

template <typename V>
Node<V>& Node<V>::operator=(const Node<V> &n1){
    if(this !=&n1) {
        std::cout << "operator = \n";
        value = n1.value;
        time = n1.time;
        visited = n1.visited;
        /// allocate new memory and coppy
        std::vector<Node<V> *> new_children;
        std::copy(n1.children.begin(), n1.children.end(), 
        std::back_inserter(new_children));
        /// deallocate old memory
        std::vector<Node<V> *> delocate;
        children.swap(delocate);
        /////
        children = new_children;
    }
    return *this;
}

template <typename V>
Node<V>& Node<V>::operator=(Node&& node){
    if( this == &node) return *this;
    /// dealacation
    children.clear();
    /// allocation
    value = node.value;
    time = node.time;
    visited = node.visited;
    children = node.children;
    /// deallocation of node
    std::vector<Node<V>*> temporary;
    node.children = temporary;
    node.visited = false;
    node.value = 0;
    node.time = 0;
return *this;
}