Nim教程【十一】

引用类型和指针类型

不同的引用可以只想和修改相同的内存单元

在nim中有两种引用方式，一种是追踪引用，另一种是非追踪引用

非追踪引用也就是指针，指向手动在内存中分配的对象；

追踪引用指向一个垃圾收集的对象；

非追踪引用是不安全的

然而对于一些低级操作（比如说访问硬件），非追踪引用是不可避免的

追踪引用用ref关键词声明

非追踪引用用ptr关键词声明

可以用[]来解包一个引用（访问一个元组或对象域时要用到）

请看下面的代码：

type
  Node = ref NodeObj
  NodeObj = object
    le, ri: Node
    data: int
var
  n: Node
new(n)
n.data = 9
# no need to write n[].data; in fact n[].data is highly discouraged!

上面代码中最后一行，没必要写成n[].data

使用new()来创建一个新的追踪对象

可以使用alloc或dealloc或realloc函数处理非追踪对象

如果一个引用没有指向任何东西，那么他的值为nil

proc方法指针类型

方法类型是一个方法的指针

（译注：一般函数式的语言中都有这个特性哦）

方法类型的变量默认值为nil

来看一下下面的代码

proc echoItem(x: int) = echo(x)

proc forEach(action: proc (x: int)) =
  const
    data = [2, 3, 5, 7, 11]
  for d in items(data):
    action(d)

forEach(echoItem)

模块

nim允许把一个程序分成若干个模块

一个模块就是一个文件

模块可以起到隐藏信息的作用（译注：面向对象的封装）

模块可以起到分开编译的作用

一个模块可以用import语句导入另一个模块的符号

在一个模块中，只有用星号标记的符号，才能导出给另一个模块

来看看下面的代码：

# Module A
var
  x*, y: int

proc `*` *(a, b: seq[int]): seq[int] =
  # allocate a new sequence:
  newSeq(result, len(a))
  # multiply two int sequences:
  for i in 0..len(a)-1: result[i] = a[i] * b[i]

when isMainModule:
  # test the new ``*`` operator for sequences:
  assert(@[1, 2, 3] * @[1, 2, 3] == @[1, 4, 9])

在这个模块文件中导出了变量x和方法*

在程序开始执行的时候就会执行模块的顶层语句，

程序员可以利用nim的这个特性来初始化一些复杂的数据结构

模块的内部可以通过使用isMainModule内置变量来判断当前模块是否为主模块

来看看下面两个模块的代码：

# Module A
type
  T1* = int  # Module A exports the type ``T1``
import B     # the compiler starts parsing B

proc main() =
  var i = p(3) # works because B has been parsed completely here

main() # Module B

import A  # A is not parsed here! Only the already known symbols
          # of A are imported.

proc p*(x: A.T1): A.T1 =
  # this works because the compiler has already
  # added T1 to A‘s interface symbol table
  result = x + 1

模块的符号的书写要符合module.symbol的语法

如果一个符号在两个模块中都定义过了

而且第三个模块引用了这两个模块

来看看下面三个模块的代码：

# Module A
var x*: string

# Module B
var x*: int# Module C

import A, B
write(stdout, x) # error: x is ambiguous
write(stdout, A.x) # no error: qualifier used

var x = 4
write(stdout, x) # not ambiguous: uses the module C‘s x

但这个规则并不适用于方法或迭代器

对于方法或迭代器来说，适用于重载的规则

来看看下面的代码：

# Module A
proc x*(a: int): string = $a# Module B
proc x*(a: string): string = $a# Module C
import A, B
write(stdout, x(3))   # no error: A.x is called
write(stdout, x(""))  # no error: B.x is called

proc x*(a: int): string = nil
write(stdout, x(3))   # ambiguous: which `x` is to call?