Допустим ли вызов деструктора в данной ситуации?

Пишу класс двусвязного списка, и у меня появилась необходимость перегрузить operator=. Кусок класса

    template<class T>
class List : public Collection<T> {
private:
    class Node {
    public:
        Node *_next;
        Node *_prev;
        T _data;
    };
    Node *_head;
    Node *_tail;
public:
    List() : _head(nullptr), _tail(nullptr) {}
    List(const T arr[]){
        for(const T &n: arr)
            this->push_back(n);
    }
    List(const List & copy): _head(nullptr), _tail(nullptr) {
        Node *temp = copy._head;
        while (temp != nullptr) {
            push_back(temp->_data);
            temp = temp->_next;
        }
    }
    ~List() {
        while (_head) {
            _tail = _head->_next;
            delete _head;
            _head = _tail;
        }
    }
    List<T> & operator=(const List & l){
        this->~List();
        Node *temp = l._head;
        while (temp != nullptr) {
            push_back(temp->_data);
            temp = temp->_next;
        }
        return *this;
    }
    void push_back(const T &data) {
        Node *newNode = new Node;
        newNode->_data = data;
        newNode->_next = nullptr;
        if (is_empty()) {
            newNode->_prev = nullptr;
            _head = _tail = newNode;
        } else {
            newNode->_prev = _tail;
            _tail->_next = newNode;
            _tail = newNode;
        }
    }
};

Как видите, тело метода скопировано из копирующего конструктора. Я не нашёл более простого способа замены списка (я же не могу вызвать копирующий конструктор над объектом this, а потом вернуть на него ук-ль?). Если подскажете как укоротить данный оператор (по возможности), я буду также благодарен?