Метод удаления из моего кругового связанного списка хорошо определен?

Я строю круговой связанный список, и я хотел бы знать, если do_remove Метод хорошо определен. Когда я запускаю программу, она показывает мне, что, тем не менее, я все еще немного сбит с толку, почему мне не нужен виртуальный разрушитель в этом случае.

Виртуальный деструктор нужен только тогда, когда я хочу уничтожить производный класс через его базовый указатель?

Означает ли это, что, понижая базовый класс до производного класса, а затем вызывая деструктор производного класса, он всегда будет вызывать деструктор базового класса?

Могут ли быть возможные утечки в do_remove метод?

PS: мне нужно, чтобы создание и уничтожение объекта было двухэтапным процессом — выделение / вызов конструктора / вызов деструктора / освобождение; вот почему я использую ::operator new в настоящее время.

Вот автономный пример кода, который я пишу:

#include <iostream>

struct NodeBase {
NodeBase * previous;
NodeBase * next;

NodeBase() noexcept
: previous(this)
, next(this) {
}

NodeBase(NodeBase * const previous, NodeBase * const next) noexcept
: previous(previous)
, next(next) {
}

~NodeBase() {
std::puts("~NodeBase()");
}
};

template <typename TYPE>
struct Node : NodeBase {
TYPE data;

template <typename ...ARGUMENTS>
Node(NodeBase * const previous, NodeBase * const next, ARGUMENTS && ...arguments)
: NodeBase(previous, next)
, data(std::forward<ARGUMENTS>(arguments)...) {
previous->next = this;
next->previous = this;
}

~Node() {
std::puts("~Node()");
}
};

template <typename TYPE>
class List {
using Node = Node<TYPE>;

int64_t this_length;
NodeBase this_sentinel;

Node * as_node(NodeBase * const input) noexcept {
return static_cast<Node * const>(input);
}

Node const * as_node(NodeBase const * const input) const noexcept {
return static_cast<Node const * const>(input);
}

template <typename ...ARGUMENTS>
List & do_insert(NodeBase * const node, ARGUMENTS && ...arguments) {
void * const address = ::operator new(sizeof(Node));
try {
new (address) Node(node->previous, node, std::forward<ARGUMENTS>(arguments)...);
++this_length;
return *this;
} catch (...) {
::operator delete(address);
throw;
}
}

// Is this method well defined?
List & do_remove(NodeBase * input) noexcept {
Node * const node = as_node(input);
input->previous->next = input->next;
input->next->previous = input->previous;
node->~Node();
::operator delete(node);
--this_length;
return *this;
}

public:
List()
: this_length(0)
, this_sentinel() {
}

~List() {
std::puts("~List()");
while (this_length) {
pop();
}
}

TYPE & head() noexcept {
return as_node(this_sentinel.next)->data;
}

TYPE const & head() const noexcept {
return as_node(this_sentinel.next)->data;
}

TYPE & last() noexcept {
return as_node(this_sentinel.previous)->data;
}

TYPE const & last() const noexcept {
return as_node(this_sentinel.previous)->data;
}

template <typename ...ARGUMENTS>
List & push(ARGUMENTS && ...arguments) {
return do_insert(this_sentinel.next, std::forward<ARGUMENTS>(arguments)...);
}

List & pop() noexcept {
return do_remove(this_sentinel.next);
}
};

int main() {

List<int> list;

list.push(5).push(7).push(3);

std::cout << list.head() << std::endl;
std::cout << list.last() << std::endl;

return 0;
}