.. _arrays:


=====
数组
=====

.. index::
    single: Arrays

数组是由从 0 到数组大小减 1 的整数索引的值序列。数组的元素可以通过其索引获得：

  var a = fixed_array<int>(1, 2, 3, 4) // 数组的固定大小为 4，内容为 [1， 2， 3， 4]
  assert(a[0] == 1)

  var b: array<int>
  push(b,1)
  assert(b[0] == 1)

替代语法为::

  var a = fixed_array(1,2,3,4)

有静态数组（固定大小，在堆栈上分配）和动态数组（大小是动态的，在堆上分配）::

  var a = fixed_array(1, 2, 3, 4) // 数组的固定大小为 4，内容为 [1， 2， 3， 4]
  var b: array<string>            // 空动态数组
  push(b, "some")                 // 现在是 包含“some” 的 1 个元素的数组
  b |> push("some")               // 与上述行相同，但使用 Pipe 运算符

可以通过范围索引从任何数组类型创建动态子数组::

  var a  = fixed_array(1,2,3,4)
  let b <- a[1..3]               //  b 是 [2,3]

实际上，`a[b]`，其中 b 是一个范围，等效于`subarray(a, b)`。

动态数组和数组元素的大小调整、插入和删除是通过一组标准函数完成的(参见 :ref:`built-in functions <stdlib__builtin>`).

相关的内置函数是： ``push``, ``push_clone``, ``emplace``, ``reserve``, ``resize``, ``erase``, ``length``, ``clear``, ``empty`` 和 ``capacity``.

数组（以及 table、structures 和 handled 类型）仅通过引用传递给函数。

数组无法复制;Only Cloned （仅克隆） 或 Moved （移动）。 ::

  def clone_array(var a, b: array<string>)
    a := b      // a 不是 b 的深层副本
    clone(a, b) // 同上

  def move_array(var a, b: array<string>)
    a <- b  // a 不指向与 b 相同的数据，b 为空。

数组可以内联构造::

	let arr = fixed_array(1.,2.,3.,4.5)

这扩展到::

	let arr : float[4] = fixed_array<float>(1.,2.,3.,4.5)

动态数组也可以内联构造::

	let arr <- ["one"; "two"; "three"]

这在语法上等同于::

	let arr : array<string> <- array<string>("one","two","three")

替代语法为::

  let arr <- array(1., 2., 3., 4.5)
  let arr <- array<float>(1., 2., 3., 4.5)

结构数组可以内联构造::

  struct Foo {
    x : int = 1
    y : int = 2
  }

  var a <- array struct<Foo>((x=11,y=22),(x=33),(y=44))    // 具有 'construct' 语法的 Foo 的动态数组（创建 3 个不同的 Foo 副本）

可以内联构造变体数组::

  variant Bar {
    i : int
    f : float
    s : string
  }

  var a <- array variant<Bar>(Bar(i=1), Bar(f=2.), Bar(s="3"))    // Bar 的动态数组（创建 Bar 的 3 个不同副本）

可以内联构造元组数组::

  var a <- array tuple<i:int,s:string>((i=1,s="one"),(i=2,s="two"),(i=3,s="three"))    // 元组的动态数组（创建 3 个不同的元组副本）

当数组元素无法复制时，使用 ``push_clone`` 插入一个值的克隆，或者使用 ``emplace`` 将其移入。

``resize`` 可能会创建新的数组元素。这些元素初始化为 0。

``reserve`` 存在是出于性能原因。通常，如果超过，数组容量会加倍。
``reserve`` 允许您指定确切的已知容量，并显著减少多个 ``push`` 作的开销。

``empty`` 告诉你动态数组是否为空。

``clear`` 清除数组，但不释放内存。它等价于 ``resize(0)`` 。

``length`` 返回数组中的元素数。

``capacity`` 返回无需重新分配即可存储在数组中的元素数。

可以通过常规的 ``for`` 循环遍历数组。 ::

  for ( x in [1,2,3,4] ) {
    print("x = {x}\n")
  }

此外，还提供了一组不安全的迭代器::

  def each ( a : auto(TT)[] ) : iterator<TT&>
  def each ( a : array<auto(TT)> ) : iterator<TT&>

两者都是不安全作的原因是它们不会捕获数组。

搜索函数可用于静态和动态数组::

  def find_index ( arr : array<auto(TT)> implicit; key : TT )
  def find_index ( arr : auto(TT)[] implicit; key : TT )
  def find_index_if ( arr : array<auto(TT)> implicit; blk : block<(key:TT):bool> )
  def find_index_if ( arr : auto(TT)[] implicit; blk : block<(key:TT):bool> )