.. _finalizers:

=========
终结器
=========

终结器是特殊函数，在两种情况下被调用:

``delete`` 在数据类型上显式调用::

    var f <- [1,2,3,4]
    delete f

基于 Lambda 的迭代器或生成器被排序::

    var src <- [1,2,3,4]
    var gen <- generator<int&> capture (move(src)) ( $ {
        for ( w in src ) {
            yield w
        }
        return false
    })
    for ( t in gen ) {
        print("t = {t}\n")
    }
    // 在捕获的 src 版本上调用 Finalizer

默认情况下，终结器在子类型上递归调用。

如果内存模型允许释放，则标准终结器也会释放内存::

    options persistent_heap = true

    var src <- [1,2,3,4]
    delete src                      // src 的内存将在此处释放

可以通过覆盖 ``finalize`` 函数来为任何类型的定义自定义终结器。
还允许使用通用自定义终结器::

    struct Foo {
        a : int
    }
    def finalize ( var foo : Foo ) {
        print("we kill foo\n")
    }
    var f = Foo(a = 5)
    delete f                    //在此处打印 'we kill foo'

--------------------------------
规则和实施细节
--------------------------------

终结器遵循以下规则：

如果自定义的 ``finalize`` 可用，则调用它而不是默认的。

指针终结器扩展为在取消引用的指针上调用 ``finalize`` ，然后在结果上调用本机内存终结器::

    var pf = new Foo
    unsafe {
        delete pf
    }

这扩展到::

    def finalize ( var __this:Foo?& explicit -const ) {
        if ( __this != null ) {
            _::finalize(deref(__this))
            delete /*native*/ __this
            __this = null
        }
    }

静态数组通常调用 ``finalize_dim`` ，它最终确定它的所有值::

    var f : Foo[5]
    delete f

这扩展到::

    def builtin`finalize_dim ( var a:Foo aka TT[5] explicit ) {
        for ( aV in a ) {
            _::finalize(aV)
        }
    }

动态数组一般调用 ``finalize`` ，它最终确定它的所有值::

    var f : array<Foo>
    delete f

这扩展到::

    def builtin`finalize ( var a:array<Foo aka TT> explicit ) {
        for ( aV in a ) {
            _::finalize(aV)
        }
        __builtin_array_free(a,4,__context__)
    }

表一般调用 ``finalize`` ，它最终确定它的所有值，但不完成它的键::

    var f : table<string;Foo>
    delete f

这扩展到::

    def builtin`finalize ( var a:table<string aka TK;Foo aka TV> explicit ) {
        for ( aV in values(a) ) {
            _::finalize(aV)
        }
        __builtin_table_free(a,8,4,__context__)
    }

为结构生成自定义终结器。批注为 @do_not_delete 的字段将被忽略。
``memzero`` 在末尾清除结构内存::

    struct Goo {
        a : Foo
        @do_not_delete b : array<int>
    }

    var g <- default<Goo>
    delete g

这扩展到::

    def finalize ( var __this:Goo explicit ) {
        _::finalize(__this.a)
        __::builtin`finalize(__this.b)
        memzero(__this)
    }

元组的行为类似于结构。无法忽略单个字段::

    var t : tuple<Foo; int>
    delete t

这扩展到::

    def finalize ( var __this:tuple<Foo;int> explicit -const ) {
        _::finalize(__this._0)
        memzero(__this)
    }

变体的行为类似于 Tuples。仅最终确定当前在用的变体::

    var t : variant<f:Foo; i:int; ai:array<int>>
    delete t

这扩展到::

    def finalize ( var __this:variant<f:Foo;i:int;ai:array<int>> explicit -const ) {
        if ( __this is f ) {
            _::finalize(__this.f)
        } else if (__this is ai) {
            __::builtin`finalize(__this.ai)
        }
        memzero(__this)
    }

Lambda 和生成器的捕获结构已最终确定。
Lambda 也可以定义自定义终结器 (参阅 :ref:`Lambdas <lambdas_finalizer>`).

类可以在类体中定义自定义终结器 (参阅 :ref:`Classes <classes_finalizer>`).