.. _clone:

=====
克隆
=====

克隆旨在创建数据的深层副本。
克隆是通过克隆运算符 ``:=``调用的::

    a := b

也可以通过变量声明中的 clone 初始化器调用::

    var x := y

这反过来又扩展为 ``clone_to_move``::

    var x <- clone_to_move(y)

(参阅 :ref:`clone_to_move <clone_to_move>`).

----------------------------------------
克隆规则和实现详细信息
----------------------------------------

克隆遵循几条规则。

某些类型（如 block、lambda 和迭代器）根本无法克隆。

但是，如果存在自定义克隆函数，则无论类型的可克隆性如何，都会立即调用该函数::

    struct Foo {
        a : int
    }

    def clone ( var x : Foo; y : Foo ) {
        x.a = y.a
        print("cloned\n")
    }

    var l = Foo(a=1)
    var cl : Foo
    cl := l                 // 调用 clone(cl,l)


通常允许在常规类型和临时类型之间进行克隆 (参阅 :ref:`Temporary types <temporary>`).

POD 类型被复制而不是克隆::

    var a,b : int
    var c,d : int[10]
    a := b
    c := d

这扩展到::

    a = b
    c = d

处理类型通过 ``canClone``, ``simulateClone``和适当的``das_clone`` C++基础设施提供自己的克隆功能 (参阅 :ref:`Handles <handles>`).

对于静态数组，调用 ``clone_dim`` 泛型，对于动态数组，调用 '``clone`` 泛型。
这些元素反过来会克隆每个数组元素::

    struct Foo {
        a : array<int>
        b : int
    }

    var a, b : array<Foo>
    b := a
    var c, d : Foo[10]
    c := d

这扩展到::

    def builtin`clone ( var a:array<Foo aka TT> explicit; b:array<Foo> const ) {
        resize(a,length(b))
        for ( aV,bV in a,b ) {
            aV := bV
        }
    }

    def builtin`clone_dim ( var a:Foo[10] explicit; b:Foo const[10] implicit explicit ) {
        for ( aV,bV in a,b ) {
            aV := bV
        }
    }

对于表，调用 ``clone`` 泛型，进而克隆其值::

    var a, b : table<string;Foo>
    b := a

这扩展到::

    def builtin`clone ( var a:table<string aka KT;Foo aka VT> explicit; b:table<string;Foo> const ) {
        clear(a)
        for ( k,v in keys(b),values(b) ) {
            a[k] := v
        }
    }

对于结构，会生成默认的 ``clone`` 函数，其中每个元素都被克隆::

    struct Foo {
        a : array<int>
        b : int
    }

这扩展到::

    def clone ( var a:Foo explicit; b:Foo const ) {
        a.a := b.a
        a.b = b.b   // 注意 复制而不是克隆
    }

对于 Tuple，每个单独的元素都被克隆::

    var a, b : tuple<int;array<int>;string>
    b := a

这扩展到::

    def clone ( var dest:tuple<int;array<int>;string> -const; src:tuple<int;array<int>;string> const -const ) {
        dest._0 = src._0
        dest._1 := src._1
        dest._2 = src._2
    }

对于变量，仅克隆当前活动的元素::

    var a, b : variant<i:int;a:array<int>;s:string>
    b := a

这扩展到::

    def clone ( var dest:variant<i:int;a:array<int>;s:string> -const; src:variant<i:int;a:array<int>;s:string> const -const ) {
        if ( src is i ) {
            set_variant_index(dest,0)
            dest.i = src.i
        } elif ( src is a ) {
            set_variant_index(dest,1)
            dest.a := src.a
        } elif ( src is s ) {
            set_variant_index(dest,2)
            dest.s = src.s
        }
    }

.. _clone_to_move:

----------------------------
clone_to_move 实现
----------------------------

``clone_to_move`` 作为内置模块的一部分通过常规泛型实现::

    def clone_to_move(clone_src:auto(TT)) : TT -const {
        var clone_dest : TT
        clone_dest := clone_src
        return <- clone_dest
    }

请注意，对于不可克隆的类型，Daslang 不会将 ``:=`` 初始化为 ``clone_to_move`` 提升。