命名法
根据C++标准§12.4 析构函数/p4,p6,p7,p8,p12 [class.dtor] (强调我的):
4 If a class has no user-declared destructor, a
destructor is implicitly declared as defaulted (8.4). An implicitly
declared destructor is an inline public member of its class.
6 A destructor is trivial if it is not user-provided
and if:
(6.1) — the destructor is not virtual,
(6.2) — all of the direct base classes of its class have
trivial destructors, and
(6.3) — for all of the non-static data members of its class
that are of class type (or array thereof), each such class has a
trivial destructor.
否则，析构函数就不重要了。
7 A destructor that is defaulted and not defined as
deleted is implicitly defined when it is odr-used (3.2) or when it
is explicitly defaulted after its first declaration.
12 A destructor is invoked implicitly
(12.1) — for a constructed object with static storage
duration (3.7.1) at program termination (3.6.4),
(12.2) — for a constructed object with thread storage
duration (3.7.2) at thread exit,
(12.3) — for a constructed object with automatic storage
duration (3.7.3) when the block in which an object is created exits
(6.7),
(12.4) — for a constructed temporary object when its
lifetime ends (4.4, 12.2). In each case, the context of the invocation
is the context of the construction of the object. A destructor is
also invoked implicitly through use of a delete-expression (5.3.5) for
a constructed object allocated by a new-expression (5.3.4); the
context of the invocation is the delete-expression. [ Note: An array
of class type contains several subobjects for each of which the
destructor is invoked. — end note ] A destructor can also be invoked
explicitly. A destructor is potentially invoked if it is invoked or as
specified in 5.3.4, 12.6.2, and 15.1. A program is ill-formed if a
destructor that is potentially invoked is deleted or not accessible
from the context of the invocation.
DR;TL
在 C++ 中如果class, struct or union没有用户声明的析构函数，那么编译器将始终为其隐式声明一个简单的析构函数。也就是说，虽然您还没有为您的析构函数声明Node根据 C++ 标准，编译器有义务为您声明一个简单的类。
这个隐式声明的简单析构函数将在您的类创建后定义odr-used。也就是说，当程序中任何位置的任何表达式获取类的对象的地址或直接将引用绑定到类的对象时。
Calling delete upon a Node先前分配的对象new将调用其隐式定义的析构函数和为该对象分配的堆存储new将被回收（即释放）。
由于隐式声明的析构函数很简单，因此成员指针指向的任何存储left and right根本不会被触动。这意味着，如果您分配了仅由left and righta 的成员指针Node目的。对该对象调用删除后，成员指针所指向的内存left and right将是孤儿（即，您将发生内存泄漏）。
核心机器级别发生了什么
核心机器级别发生的情况可能因供应商、操作系统和机器而异，因为 C++ 标准未指定删除表达式的核心行为。只要可观察的行为符合 C++ 标准，任何编译器供应商都可以做任何想做的事情（例如，优化）。
不过，供应商或多或少也在做类似的事情。例如，让我们考虑以下代码：
class Node {
int i;
Node *left, *right;
};
int main() {
Node *n = new Node;
delete n;
}
上述代码为 GCC 6.2 版编译器生成的汇编代码为：
main:
push rbp
mov rbp, rsp
sub rsp, 16
mov edi, 24
call operator new(unsigned long)
mov QWORD PTR [rbp-8], rax
mov rax, QWORD PTR [rbp-8]
mov esi, 24
mov rdi, rax
call operator delete(void*, unsigned long)
mov eax, 0
leave
ret
在为我们的简单示例生成的汇编代码中，构造了n对象由下面的代码片段表示：
sub rsp, 16
mov edi, 24
call operator new(unsigned long)
mov QWORD PTR [rbp-8], rax
由于该对象是可简单构造的，因此编译器所做的唯一事情就是通过调用隐式声明的全局运算符为该对象分配内存new.
对象的销毁过程由下面的代码片段表示：
rax, QWORD PTR [rbp-8]
mov esi, 24
mov rdi, rax
call operator delete(void*, unsigned long)
请注意，销毁过程是按照与构造过程中所采取的步骤相反的顺序完成的。最后隐式声明的全局运算符delete被调用以释放先前分配的内存。
在我们的示例中，构造函数和析构函数都没有被调用，因为在我们的例子中，如果不调用它们，程序的可观察行为不会改变。
现在正确的问题是到底在哪里operator delete is?
为了保留这个答案的命名风格，让我们引用 C++ 标准§3.7.4 Dynamic storage duration [basic.stc.dynamic]\p1, p2 (重点我的):
1 Objects can be created dynamically during program
execution (1.9), using new-expressions (5.3.4), and destroyed using
delete-expressions (5.3.5). A C++ implementation provides access to,
and management of, dynamic storage via the global allocation functions
operator new and operator new[] and the global deallocation functions
operator delete and operator delete[]. [ Note: The non-allocating
forms described in 18.6.2.3 do not perform allocation or deallocation.
— end note ]
2 The library provides default definitions for the global
allocation and deallocation functions. Some global allocation and
deallocation functions are replaceable (18.6.2). A C++ program shall
provide at most one definition of a replaceable allocation or
deallocation function. Any such function definition replaces the
default version provided in the library (17.5.4.6). The following
allocation and deallocation functions (18.6) are implicitly declared
in global scope in each translation unit of a program.
void* operator new(std::size_t);
void* operator new(std::size_t, std::align_val_t); void operator delete(void*) noexcept;
void operator delete(void*, std::size_t) noexcept;
void operator delete(void*, std::align_val_t) noexcept;
void operator delete(void*, std::size_t, std::align_val_t) noexcept;
void* operator new[](std::size_t);
void* operator new[](std::size_t, std::align_val_t);
void operator delete[](void*) noexcept;
void operator delete[](void*, std::size_t) noexcept;
void operator delete[](void*, std::align_val_t) noexcept;
void operator delete[](void*, std::size_t, std::align_val_t) noexcept;
这些隐式声明仅引入函数名称运算符new, operator new[], operator delete, and operator delete[]。 [
注意：隐式声明不引入名称std,
std::size_t, std::align_val_t，或图书馆认为的任何其他名称
用于声明这些名称。因此，新表达式、删除表达式
或引用这些函数之一的函数调用，而无需
包括标题格式良好。但是，参考标准
或 std::size_t 或 std::align_val_t 格式错误，除非名称具有
通过包含适当的标头来声明。 ——尾注]
分配和/或释放函数也可以被声明和
为任何类定义（12.5）。
答案是删除运算符在程序的每个翻译单元的全局范围内隐式声明。
