标签 Clisp 下的文章

C程序员驯服Common Lisp – 函数

Common Lisp函数式编程语言,其基本组成单元自然是函数。对Common Lisp函数的理解也是学习Common Lisp语言的关键。另外与C语言以内存单元修改为主要编程方法不同,Common Lisp的主要编程方法是将函数应用于参数。这里我们分别用两种范式风格实现同一个函数,该函数用于取得第n个fibonacci数(n从0开始):

;; 命令式风格
(defun imperative-fibonacci (n)
    (let ((first 0)
          (second 1)
          (sum 0))
        (dotimes (i n)
            (progn
                (setf sum (+ first second))
                (setf first second)
                (setf second sum)))
        first))

;; 函数式风格
(defun functional-fibonacci (n)
    (cond 
        ((= 0 n) 0)
        ((= 1 n) 1)
        (t (+ (functional-fibonacci (- n 1)) (functional-fibonacci (- n 2))))))

对比一下我们可以看出函数式风格代码更加简洁,可读性更强,更易于理解。虽然使用Common Lisp也可以写出命令式风格的代码,不过我们强烈建议你使用函数式风格,这才是Common Lisp的首选范式 – 即用自然而然的函数嵌套调用或递归调用,而不是堆砌一些修改变量值的语句。C语言中也有函数,但与Common Lisp语言中函数的区别就在于其内部实现均为对变量的修改操作,就像上面例子中imperative-fibonacci函数定义的那样。

一、定义新函数
Common Lisp使用defun宏来定义一个新函数,其语法形式如下:
(defun function-name (param*)
    "Optional documentation string."
    expr1
    expr2
    expr3
    … )

其实我在之前的几篇文章以及上面的例子中已经多次用到了defun宏,与C语言的函数原型相比,defun定义的函数缺少了一些类型信息,包括返回值类型信息和参数列表中参数的类型信息。

defun定义的函数在全局作用域可见,即使这个定义是嵌套在另外一个函数定义中的(标准C是不允许函数嵌套定义的):
[1]> (defun foo (x)
        (print x)
        (defun bar (y)
            (print (1+ y))))
FOO
[2]> (foo 1)
1
BAR
[3]> (bar 2)
3

注意:嵌套在其他函数定义中函数定义,如bar,其生命周期起始于外围函数执行后,例如例子中foo函数未执行前,bar是未定义的。

对于C程序员来说,也许Common Lisp函数定义与C函数定义最大的不同在函数参数列表上。C语言的函数只支持两种参数列表形式:定长参数列表和变长参数列表,比如:
int main(int argc, char* argv[]); /* 定长参数列表 */
int printf( const char* format, …);  /* 变长参数列表 */

而Common Lisp函数对参数列表的支持更加灵活,参数的类型更加丰富,功能也更为强大。下面我们逐一来看。

Common Lisp函数参数列表默认都是定长的,参数也是必选的(required),也就是说参数列表中有几个形式参数,你在调用该函数时就需要传入等量的实际参数,不能多,也不能少,例如:
[1]> (defun foo (x y) (print (+ x y)))
FOO
[2]> (foo 1)
*** – EVAL/APPLY: too few arguments given to FOO
[3]> (foo 1 2 3)
*** – EVAL/APPLY: too many arguments given to FOO
[4]> (foo 1 2)
3

除了参数列表的必选参数外,Common Lisp还支持可选参数(Optional Parameter)。参数列表中的可选参数由&optional指定,例如:
(defun foo (a b &optional c d)
    (print a)
    (print b)
    (print c)
    (print d))

其中位于&optional后面的c,d为可选参数;如果未显式指定默认值,则其值为NIL。
[1]> (foo 1 2)
1
2
NIL
NIL

我们可以为可选参数指定默认值,例如:
(defun foo (a b &optional (c 10) (d 11))
    … …)
[2]> (foo 1 2)
1
2
10
11

可以看出对于指定了默认值的可选参数,如果调用时没有为可选参数传入实际参数,则可选参数将绑定默认值。可选参数的默认值不仅仅可以是常量值,还可以是全局变量或该可选参数左侧的某个必选参数,例如:
(defvar *x* 13)
(defun foo (&optional a b c (d *x*))
    … …)

(defun foo (&optional a b c (d a))
    … …)
 
如果有必选参数,那可选参数必须放在必选参数的后面,但我们可以将一个函数的所有参数都定义为可选参数,如:
(defun foo (&optional a b (c 10) (d 11))
    … …)

在带有可选参数的函数体内我们如何知道该函数被调用时外面是否给可选参数传入实际参数了呢?Common Lisp提供了一个指示器,你可以将该指示器放在可选参数默认值的后面,就像这样:
(defun foo (&optional a b (c 10) (d 11 d-supplied-p))
    (print a)
    (print b)
    (print c)
    (print d)
    (print d-supplied-p))

如果函数在执行时可选参数绑定了实际参数而不是默认值,则该指示器的值将为T,否则为NIL。
[1]> (foo 1 2 3 4)
1
2
3
4
T
[2]> (foo 1 2)
1
2
10
11
NIL

Common Lisp语言引入可选参数至少有两个用途,一是为了适应某些场合的需求:一些场合的确不需要显式为所有参数传递实际参数;二是我们通过可选参数可以为某些参数显式地设置默认值。

在Common Lisp中,与C语言变长参数列表对应的是函数列表中的rest参数。rest参数通过在参数前面的&rest关键字修饰。通过rest参数,我们可以定义出类似format这样接受不定个数参数的函数,例如:
[1]> (defun foo (x y &optional z &rest others)
        (print x)
        (print y)
        (print z)
        (mapcar #'print others))
[2]> (foo 1 2 3 4 "hello lisp")
1
2
3
4
"hello lisp"
(4 "hello lisp")

在函数定义内部rest参数是以一个list的形式存在的,例如上面例子中,传入函数体内的参数others的值实际上是(4 "hello lisp")。

我们知道C语言虽然支持变长参数列表,但其参数列表中至少需要有一个必选参数,例如:int printf( const char* format, …)中的format参数是无法省略的;但是Common Lisp就不同,Common Lisp支持完全的变长参数列表,例如:(defun my-add (&rest addends) …)

Common Lisp还提供一种C语言中没有的参数类型 – keyword参数。keyword参数允许你只为参数列表中的某个特定参数传入实际参数,这种能力是rest和optional参数所不具备的。我们可以通过&key来指示keyword参数,如:
[1]> (defun foo (&key x y z)
        (print x)
        (print y)
        (print z))

作为keyword参数,如果在函数调用时没有为其显式赋值,那么该参数的值将为NIL。我们可以通过如下方式为特定的keyword参数赋值:
[2]> (foo :y 2)
NIL
2
NIL

Keyword参数赋值是不用考虑赋值先后的顺序的,例如:
[3]> (foo :z 11 :x 13)
13
NIL
11

对于带有keyword参数的函数,调用该函数时要么不为任何keyword参数传参,要么至少为其中某一个keyword参数传参,不能只为必选参数传参,如:
[1]> (defun foo (&key x y z)
        (print x)
        (print y)
        (print z))
[2]> (foo 1)
*** – FOO: keyword arguments in (1) should occur pairwise

与Optional参数类似,keyword参数也可以指定默认值,也可以通过指示器来标定keyword参数到底是否绑定了外面传入的实际参数,其中默认值既可以是常量也可以是其左侧其他keyword参数组成的表达式,例如:
[1]> (defun foo (&key (x 17) (y 15 y-supplied-p) z)
        (print x)
        (print y)
        (print y-supplied-p)
        (print z))

[2]> (foo :z 23)
17
15
NIL
23

在之前有关keyword参数的例子中我们使用的形式参数多以x,y这样的简单名字命名,这些名字虽便于函数定义内部使用,但是对于这个函数的调用者来说,这些名字却没有什么实际含义。keyword参数支持通过别名方式解决这个问题:
[1]> (defun foo (&key ((:name a)) ((:age b)) ((:gender c) "Unknown"))
        (print a)
        (print b)
        (print c))
[2]> (foo :name "tony" :age 29)
"tony"
29
"Unknown"

Common Lisp中函数的返回值默认为函数体中最后执行的那个表达式的求值结果,上面举的例子也都是这种情况。在C语言中我们通过return语句可以从函数体内的任何位置主动退出该函数,在Common Lisp中我们同样可以用return-from达到这一目的,例如:
[1]> (defun foo (x y)
        (if (< x 0)
            (return-from foo "IIlegal X Value"))
        (if (< y 0)
            (return-from foo))
        (+ x y))
FOO
[2]> (foo 1 2)
3
[3]> (foo -1 2)
"IIlegal X Value"
[4]> (foo 1 -2)
NIL

对于函数而言,return-from的语法形式为:(return-from func-name optional-value),若不指定返回值,那么默认return-from的返回值为NIL。

二、匿名函数
与C语言不同,Common Lisp支持定义匿名函数,例如:
[1]> (funcall #'(lambda (x) (print (1+ x))) 2)
3

上面例子中这行语句既包含了函数定义,也包含了函数调用。与之前使用defun定义有名函数不同的是,这次我们定义出来的函数没有指定函数名,这种使用lambda关键字定义的函数被称作为匿名函数。

从例子中也可以看出,匿名函数的定义也很简单,其一般形式为:
(lambda (args*) body-form*)

我们也称这种表达式为lambda表达式。lambda表达式定义的匿名函数与有名函数一样,也支持使用optional,rest和keyword参数。

三、高阶函数
函数式编程语言与命令式语言除了在风格方面的不同之外,最大的不同点之一在于函数式语言中函数已经成为了一等公民(first-class citizen),与整型、字符串等原生类型具有同等的地位。更具体地说,函数成为一等公民意味着我们可以像对待整型数、字符串那样将函数当作数据对待:将函数赋值给变量、将函数作为参数传递给其他函数以及将函数作为返回值返回给函数调用者等等。作为C程序员你也许会说这似乎与C语言中的函数指针很类似啊,但别忘了C语言真正原生支持的是类型是指针,而不是函数。

有了一等公民地位的函数,我们就得到了高阶函数。高阶函数就是那些接受其他函数为函数或将其他函数作为返回值的函数。例如Common Lisp提供的标准函数sort就接受一个比较函数作为参数:
[1]> (defun integer-over-than (x y) (> x y))
INTEGER-OVER-THAN
[2]> (sort '(5 2 98) (function integer-over-than))
(98 5 2)
[3]> (sort '("hello" "world") (function string>=))
("world" "hello")

标准库中的sort函数接受一个自定义的比较函数作为参数,并在内部将传入的函数应用于参数list。例子中我们没有直接将integer-over-than传给sort,而是使用了(function integer-over-than)。function是Common Lisp提供的一个特殊操作符,将其应用于函数名可以得到该函数名对应的函数对象。比如通过(function foo),我们可以得到名字为foo的内部函数对象。如果没有foo这个函数定义,解释器会提示"undefined function FOO"。可以看出真正被当作一等公民对待的不是foo这个符号,而是foo这个符号名字背后所对应的那个函数对象,也就是函数在Common Lisp中的内部表示形式。我们在将函数绑定到某个变量或将函数传递给某个函数作为实际参数时,我们都需要使用这个内部函数对象,而不是foo这个符号,例如:
[1]> (sort '(5 2 98) integer-over-than)
*** – EVAL: variable MY-OVER-THAN has no value
[2]> (setf *sort-func* integer-over-than)
*** – EVAL: variable MY-OVER-THAN has no value
[3]> (setf *func* (function my-over-than))
# FUNCTION MY-OVER-THAN (X Y) (DECLARE (SYSTEM::IN-DEFUN MY-OVER-THAN)) (BLOCK MY-OVER-THAN (> X Y))>

Common Lisp提供了一个语法糖用于简化function的使用,即我们可以用#'代替function操作符,比如:#'foo就等价于(function foo)。

那么在接受函数作为参数的函数定义内部我们如何使用函数对象呢?Common Lisp提供了两个函数funcall和apply用来执行函数对象对应的函数。我们先以funcall为例,funcall的语法形式如下:
(funcall function-obj args*)

例如:
[1]> (defun foo (x y) (print (+ x y)))
FOO
[2]> (defun my-add (x y f) (funcall f x y))
MY-ADD
[3]> (my-add 1 2 #'foo)
3

apply与funcall的不同之处在于其接受的参数格式有不同,apply的语法形式如下:
(apply function-obj args* other-args-list)

直观地比较:(apply #'+ '(1 2 3))就等价于(funcall #'+ 1 2 3),不同的是使用apply需要将各个参数打包到一个list中,或至少保证最后一个参数为list。下面几种调用方式与(apply #'+ '(1 2 3))都是等价的:
(apply #'+ 1 '(2 3))
(apply #'+ 1 2 '(3))

lambda表达式用于定义一个匿名函数,我们同样可以通过#'来获得这个匿名函数对应的函数对象,例如:
#'(lambda (x y) (print (+ x y)))

匿名函数对象可以直接作为实际参数传递给函数,我们也可以通过funcall来直接执行匿名函数,例如:
[1]> (my-add 1 2 #'(lambda (x y) (print (+ x y))))
3
[2]> (funcall #'(lambda (x y) (print (+ x y))) 1 2)
3

以上是推荐的标准用法,下面方法(去掉了lambda前面的#')虽然也可以达到相同效果,但不推荐使用:
[1]> (my-add 1 2 (lambda (x y) (print (+ x y))))
3
[2]> (funcall (lambda (x y) (print (+ x y))) 1 2)
3
[3]> ((lambda (x y) (print (+ x y))) 1 2)
3

在C语言中我们通过函数指针和回调手法也可以模拟一些高阶函数的行为,这里就不赘述了。

四、闭包(Closure)
市面上有很多编程语言都支持闭包,比如JavaScript,Python,Perl,Ruby等。这里所说的闭包不是离散数学里的那个闭包,而是编程语言引入的一种机制,目前对于编程语言中的闭包尚未有一个精确的定义,但一般认为闭包是引用了外部作用域(但不是全局作用域)的变量的函数,这个被引用的变量与这个函数一同存在,即使是脱离了定义它们的上下文环境。

Common Lisp支持闭包,关于Common Lisp闭包的一个最典型例子是这样的:
[1]> (setf *fn* (let ((i 0))
            #'(lambda () (setf i (+ i 1)))))
#FUNCTION :LAMBDA NIL (SETF I (+ I 1))>
[2]> (funcall *fn*)
1
[3]> (funcall *fn*)
2
[4]> (funcall *fn*)
3

按照之前我们对变量的理解,let引入的i只是一个局部变量,在离开定义的环境后,该变量生命周期将终结。理论上我们三次调用*fn*所对应的你们函数得到的结果应该是相同的才对。但就是由于在let构造的局部作用域内的那个匿名函数引用了外部的变量i,导致变量i可以脱离其原生作用域的束缚,让其生命周期等同于了其内部的那个匿名函数,这个内部的匿名函数就被称为闭包,而那个被引用的外部变量被成为自由变量(free variable)。当我们连续调用函数*fn*时,i就像一个全局变量一样,每次值都加一。

引用了自由变量的闭包似乎是终结了自由变量的局部绑定关系,将自由变量从局部作用域环境中取出,并重新放入一个与闭包同生命周期的新作用域。自由变量会常驻内存中,这也是闭包的常用场景之一。闭包的另外一个用途可能就是出于保护自由变量的考虑,让自由变量只有通过闭包函数才能访问到。

C程序员驯服Common Lisp – 变量

变量是C语言中最常用的、不可或缺的语言元素。C语言是命令式编程语言(imperative programming language),其基本编程方法是基于对内存单元的修改,而变量又恰是对内存单元的抽象表示,比如:"int a = 0xff"这行语句告诉我们在内存中有一块大小为4个字节的区域,该区域可以通过a这个变量直接访问,该区域初始时存储的值为0xff。由此看来C语言的主要操作就是变量操作。

C语言中变量的使用有着严格要求:
第一,在使用一个变量之前必须先声明(或定义)这个变量;
第二,变量声明(或定义)时必须显式指出这个变量的数据类型;
最后,变量类型一旦确定,则在其生命周期内不能改变。
这些也是C语言作为静态编译型语言的特质所决定的。下面代码中关于变量使用的语句在C语言中都是不被允许的:

void foo(void) {
    printf("%d\n", x); /* x变量未被声明或定义 */
}

void bar(void) {
    x;
    printf("%d\n", x); /* 未显式指定x的数据类型,变量声明语句不合法 */
}

与C语言不同,Common Lisp是一门通用的函数式编程语言,其基本编程方法是基于对函数的求值,并要求尽量避免引入可改变的(mutable)变量和状态。另外再加上Common Lisp还是一门动态类型语言,这些都决定了其在变量的使用方面与C语言有着较大的差异。

一、赋值
在C语言中,我们用等号(=)来为变量进行赋值,如:
int a = 13;
char *str = "hello c";
struct foo f = {1, 5, "foo"};

但Common Lisp程序是基于S-expressions的,等号(=)只是一个相等性比较的逻辑判断谓词(predicate),无法为变量进行赋值。在Common Lisp中,宏setf才是最通用也是最常使用的赋值方法。setf的语法形式如下:
(setf var-expression value-expression)

例如:
[1]> (setf x 5)
5
[2]> (print x)
5
[3]> (setf x "hello lisp")
"hello lisp"
[4]> (print x)
"hello lisp"

从这个例子中我们可以看出三点与C语言的不同之处:
1、Common Lisp变量在使用前是无需显式声明的(当然显式声明也是可以的哦,详见后面说明);
2、变量无类型信息;
3、变量在运行时可以被赋值为多种类型的值,比如此例中x先被赋值为一个整数,后又被赋值为一个字符串。

C语言的变量是内存单元的直接抽象,但Common Lisp中的变量想必不是这样的,它似乎更像是一个void*指针,被赋值为各种类型的对象地址。没错,其实Common Lisp变量的实质是一个引用(reference),对这类变量赋值的实质就是将引用与存储了真实值的内存块地址绑定起来,setf这个宏达到的实际效果就是改变了引用与值的绑定关系而已。通过这里我们似乎还可以引伸出一点,那就是Common Lisp中的变量本身并不包含类型信息,相反,值才是类型信息的载体,变量的类型取决于变量所绑定的值的类型。

二、局部变量(Local Variable)
作用域是变量的最重要属性之一。根据变量的作用域不同,在C语言中我们可以将变量简单地划分为全局变量(Global Variable)和局部变量。顾名思义,全局变量就是在程序的所有作用域内均可以访问的变量;局部变量恰与之相反,只是在某一特定作用域才可以访问的变量,比如某一函数或代码块内部。Common Lisp也支持这两种类型的变量,我们先从局部变量说起。

与C类似,Common Lisp的局部变量也是在函数内部或代码块内部定义和使用的。Common Lisp通过let宏定义一个局部变量,let宏的语法形式如下:
(let (var*)
     expr1
     expr2
     … )

其中每个var的语法形式为:(name initial-value),如果未指定initial-value,则变量初值将被设置为nil。最后一个expr的求值结果将作为let的返回值。例如:

[1]> (defun bar ()
        (let ((x 0)) (setf x 4)))
BAR
[2]> (bar)
4
[3]> (print x)
*** – EVAL: variable X has no value

let引入的局部变量x的作用域仅限于bar的内部,在bar外部无法访问到这些变量,变量x的生命周期也是从bar的执行开始,直到bar执行结束为止。

let一次可声明多个局部变量,并可嵌套使用:
[1]> (defun foo ()
        (let ((x 1) (y 2))
            (print x)
            (print y)
            (setf x 3)
            (let ((z 4))
                (print x)
                (print z))))
FOO
[2]> (foo)
1
2
3
4

局部变量的默认作用域属于静态作用域(lexical scope或static scope),静态作用域是指变量的作用域在执行前即可确定下来,每个函数或代码块中的局部变量均可以在当前函数(或代码块)中或其外层函数(或外层代码块)中找到对应的声明或定义。如上例中,函数foo内有两层let嵌套。外层let引入的变量x和y在当前函数内即可找到对应的定义;最里层的let代码块中使用的变量x在外层的foo函数定义中可以找到相应的定义。一旦找到绑定关系,变量的值就不会因执行环境不同而发生变化了。

和C语言类似,如果局部作用域中的不同层次定义了相同名字的局部变量,那么内层的局部变量将遮盖外层的变量,如:
[1]> (defun bar ()
        (let ((x 1))
            (print x)
            (let ((x 11))
                (print x)
                (setf x (1+ x))
                (print x))
            (print x)))
BAR
[2]>
1
11
12                   
1

求值内层x的值时,Common Lisp找到的是最内层的x定义,最内层的变量x当前绑定值为11,我们看到的输出结果也的确是11。在外层,变量x对应的定义为(x <– 1),这样外层输出的x的值就为1。

前面例子中定义的函数都是不带参数的,这是故意为之,因为下面我要说函数的形式参数。在C语言中,函数的形式参数与函数内的局部变量是等价的,其作用域也仅局限在函数内部。Common Lisp也是这样的,函数的形式参数本身就可以理解为函数内部的局部变量,在函数被求值时,Common Lisp在函数的形式参数与实际参数间建立绑定关系:
[1]> (defun foo (x)
        (print x)
        (setf x 13)
        (print x))
FOO
[2]> (foo 4)
4
13

从例子中我们可以看出foo函数在求值时,形式参数x与实际参数4建立绑定,第一个(print x)输出结果为4;在foo内部,我们利用setf改变了x的绑定关系后,x值变为13;函数foo内部使用的变量x对应的定义就是foo的形式参数。无论日后foo在什么上下文环境下执行,该x对应的定义都是固定的了,如:
[3]> (let ((x 5)) (foo 4))
4
13

与C语言不同的是,Common Lisp还支持动态作用域(dynamic scope),这种作用域在如今主流编程语言中已经不常见了。与静态作用域相反,具有动态作用域的变量在执行之前无法确定其定义,也就是说变量的定义不取决于其所在函数或代码块定义时的环境,而是取决于其所在函数或代码块执行时所处的上下文环境,因此其定义或者说绑定关系只能在运行时确定。

对于局部变量,Common Lisp通过(declare (special var-name))来显式声明var-name这个变量为动态作用域变量,又称动态变量(dynamic variable)。动态变量理解起来很不容易,但若明白其实现原理,理解起来就相对轻松许多了。每个动态变量都会对应一个全局绑定关系栈(stack),在某作用域中遇到一个局部变量定义或新绑定,解释器就会将该新绑定关系压入堆栈;当离开该作用域后,绑定关系被弹出栈。这样当试图确定某个变量的绑定关系时,我们可以直接从栈顶获得绑定关系。如果对应该变量的栈为空时,即判定该变量未绑定任何值,解释器会报错。我们再来通过一个例子来加深一下了解吧:

[1]> (defun foo ()
        (declare (special x))
        (print x))
FOO
[2]> (let ((x 6)) (foo))
*** – EVAL: variable X has no value

我们定义了一个函数foo,在foo中我们声明了x为动态变量。当我们执行(let ((x 6)) (foo))时,解释器提示X没有绑定任何值。这是怎么回事儿呢?我们还是用原理来一步一步分析。

按照执行顺序,解释器先遇到局部变量x的定义,将x与数值6建立绑定,同时确定x为局部变量,但并非动态变量。执行foo时,foo中的变量x为动态变量,解释器为其建立全局绑定关系栈,但是在foo中并没有变量x的定义,所以x对应的全局绑定关系栈为空,导致执行(print x)时出错。

我们修改一下代码:
[1]> (defun foo ()
        (declare (special x))
        (print x))
FOO
[2]> (let ((x 6)) (declare (special x)) (foo))
6

按照执行顺序,解释器先遇到局部变量x的定义,将x与数值6建立绑定,同时发现x被显式声明为动态变量,解释器为x建立全局绑定关系栈,并将其绑定关系(x <- 6)压入栈;接下来执行foo函数,foo中的变量x为动态变量,且当前已经建立全局绑定关系栈,继续执行(print x),从栈顶得到绑定关系(x <- 6),得到求值结果,最后解释器离开该作用域,将绑定关系弹出栈。

三、全局变量
与局部变量对应的是全局变量。全局变量拥有全局作用域,即在一个程序内部的任何地方都可以访问到全局变量。Common Lisp通过defvar或defparameter宏显式定义一个全局变量(虽然这不是必须的):
[1]> (defvar *x* 13)
*X*
[2]> (print *x*)
13
[3]> (defparameter *y* 14)
*Y*
[4]> (print *y*)
14

defvar与defparameter的语法形式如下:
(defvar var-symbol optional-initial-value
      optional-documentation-string)
(defparameter var-symbol initial-value
      optional-documentation-string)

defvar与defparameter的不同之处在于声明中可以不为全局变量绑定初值,而defparameter则是严格要求必须为声明中的全局变量绑定初值,比如:
[1]> (defvar *x*)
*X*
[2]> (defparameter *y*)
*** – The macro DEFPARAMETER may not be called with 1 arguments: (DEFPARAMETER *Y*)

局部变量可以显式地被指定为动态变量,全局变量是否可以呢?我们看看下面的例子:
[1]> (defvar *x* 11)
*X*
[2]> (defun foo ()
        (print *x*))
FOO
[3]> (foo)
11
[4]> (let ((*x* 13)) (foo))
13
[3]> (foo)
11

从例子中我们看出,全局变量本身似乎就是一个动态变量。我们猜的没错。对于使用defvar或defparameter显式定义的全局变量,Common Lisp同时为其赋予了动态属性,也就是说defvar或defparameter定义的全局变量本身就是一个动态变量。其在动态作用域中的工作原理与上面在局部变量中提到的动态变量的原理是相同的。就拿上面的例子来说:
1) 我们使用defvar定义*x*时,解释器就为*x*建立了全局绑定关系栈,并将绑定关系(*x* <- 11)压入栈;
2) 执行(foo)时,解释器从栈顶得到*x*的当前值为11;
3) 执行(let ((*x* 13)) (foo))时,解释器又将动态变量*x*的新绑定关系(*x* <- 13)压入栈,这样在执行后面的(foo)时,栈顶的绑定关系就为(*x* <- 13),即执行结果为13;当解释器执行体离开该作用域时,绑定关系(*x* <- 13)从栈中弹出;
4) 最后再执行(foo),栈顶的绑定关系已经变成了(*x* <- 11),所以(foo)的执行结果又变成了11。

使用setf也可以隐式地引入一个全局变量,但与使用defvar或defparameter显式定义的全局变量不同,setf引入的全局变量并非动态变量:
[1]> (setf *x* 11)
11
[2]> (defun foo ()
        (print *x*))
FOO
[3]> (foo)
11
[4]> (let ((*x* 13)) (foo))
11

在使用源文件编写代码的情况下,我们推荐使用defvar或defparameter定义全局变量。

另外不得不提的是动态变量是把双刃剑,动态变量在函数(子程序)层次之间建立一个隐含的关系,减少了参数传递。但同时也降低了程序的可读性,可靠性以及运行性能。

四、常量
C程序员更喜欢使用宏来表示常量,但Common Lisp提供了专门的defconstant宏来定义一个常量,其语法形式如下:
(defconstant var-symbol value
      optional-documentation-string)

关于常量的内容很简单,但这里还是要注意以下两点:
1、和全局变量类似,Common Lisp常量也有自己的命名惯例,一般以"+constant-name+"为命名格式,名字两旁各加一个加号(+),不过这个惯例的受重视程度和遵守程度显然不如全局变量那个;
2、常量的名字不能用于作函数的形式参数,比如:
[1]> (defconstant +y+ 2)
+Y+
[2]> (defun foo (+y+) (print +y+))
*** – FUNCTION: +Y+ is a constant, may not be used as a variable

C程序员驯服Common Lisp – 控制结构

光有表达式,我们依旧无法写出实用的程序,我们还缺少控制结构(Control Structures)。

C语言主要有三种控制结构:顺序结构、条件分支结构和循环结构。Common Lisp
也实现了类似的控制结构,我们逐一来看。

一、顺序结构
顾名思义,顺序结构中的语句或表达式是按其位置的先后顺序依次执行的,这也是最简单也最容易理解的一种结构。在C语言中,绝大多数代码块(code block)中的代码都是顺序结构的。Common Lisp程序由S-expressions组成,其本质上的执行过程为自左向右的求值过程。不过Common Lisp的代码编排风格会让给大家一种错觉:Common Lisp似乎也是顺序执行的,例如:

;;以下是来自于《Practical Common Lisp》书中的一段代码
(defun prompt-for-cd ()
  (make-cd
     (prompt-read "Title")   
     (prompt-read "Artist")
     (or (parse-integer (prompt-read "Rating") :junk-allowed t) 0)
     (y-or-n-p "Ripped [y/n]: ")))

Common Lisp确实提供了一个Special operator – progn(注意progn不是函数),可用于在一个代码块中真正顺序地执行一组表达式。其语法形式如下:
(progn
    (form-1)
    (form-2)
    .
    .
    .
    (form-N))

Common Lisp会顺序地执行form-1,form-2,…. form-N,并将最后一个表达式form-N的求值结果作为progn的返回值,例如:
[1]> (progn
        (print "hello world")
        (print "hello lisp")
        (print "hello graham"))
"hello world"
"hello lisp"
"hello graham"
"hello graham"

最后的"hello gramham"即为progn的返回值,并被顶层环境再次输出。progn的行为让我想起了C语言中的逗号表达式"expr1, expr2, … , exprn",与progn一样,逗号表达式也是依次执行expr1,expr2,…,并返回最后一个expression的值。

二、条件分支结构
C语言中最常见的条件分支结构莫过于if语句了。if语句是一个典型的开关结构或叫二选一结构,即if后面的条件成立,执行一个分支;否则执行另外一个分支。其典型结构如下:
if (cond expr) {
    … …
} else if (cond expr) {
    … …
} else if (cond expr) {
    … …
} else {
    … …
}

Common Lisp中也有if。与progn一样,Common Lisp中的if也是一个special operator而不是函数。函数的原则是必须对所有参数都进行求值,且对每个参数仅进行一次求值;而if和progn则不一定需要对所有"参数"进行求值。Common Lisp中if的语法形式如下:
(if cond-form
    then-form
    [else-form])

Common Lisp中的if首先对cond-form进行求值,如果为真,则对then-form求值,并将结果返回;否则返回else-form的求值结果。如果没有else-form分支,则返回nil。这与C语言中的条件表达式:"condition_expression ? then_expression : else_expression"甚为相似。下面是一个例子:

[1]> (if (> 3 2) (+ 4 5) (- 11 3))
9
[2]> (if (< 3 2) (+ 4 5) (- 11 3))
8
[3]> (if (< 3 2) (+ 4 5))
NIL
[4]> (if (= 2 2)  ;; if级联示例
        (if (> 3 2) 4 6)
        9)
4

除了if,Common Lisp还提供了其他一些简便实用的条件分支控制operator。

我们常常会在某个条件分支中顺序地执行多个表达式,这种情况下,我们用if实现的代码如下:
(if (cond-form)
    (progn
        (form1)
        (form2)
        (form3)))

Common Lisp提供了操作符when来应对如此需求,并简化你的代码:
(when (cond-form)
        (form1)
        (form2)
        (form3))

当cond-form求值为真时,when会顺序从form1执行到form3。

Common Lisp还提供了unless,用于否定语义的判断:
(unless (cond-form)
        (form1)
        (form2)
        (form3))

仅当cond-form求值为nil时,form1到form3才会被顺序执行,否则返回nil。

我们日常还会遇到条件分支特别多的情况,如:
if (cond-1)
    statments-1
if (cond-2)
    statments-2
… …
if (cond-n)
    statments-n

此时如果用if来实现,代码就显得层次太深,不够简洁,可读性不好,也难于后续维护:
(if (cond-1)
    (statments-1)
    (if (cond-2)
        (statments-2)
        …..
            (if (cond-n)
                (statments-n))))

Common Lisp提供了cond操作符来应对这一情况:

(cond
    ((cond-1) (statments-1))
    ((cond-2) (statments-2))
    … …
    ((cond-n) (statments-n)))

C语言中还有一种分支结构switch…case,可用于将一个变量与诸多常量相比较。变量与哪个case中的常量相等,就继续执行该case所在的分支代码。有些资料中将该结构称为选择结构,这里我把它统一划归在条件分支一类中。因为只有满足case条件,执行权才会进入到这个分支:
switch (expression) {
    case (const expression):
        statments;
        … …
    case (const expression):
        statments;
    default:
        statments;
}

Common Lisp中也有与switch…case对应的结构:case。
[1] > (defun grade-meaning (grade)
        (case grade
            ((5) "Excellent")
            ((4) "Good")
            ((3) "Average")
            ((2) "Poor")
            ((1) "Failing")
            (otherwise "Illegal grade")))
GRADE-MEANING
[2]> (grade-meaning 5)
"Excellent"
[3]> (grade-meaning 1)
"Failing"
[4]> (grade-meaning 0)
"Illegal grade"

case结构中的otherwise类似与C语言中switch…case中的default分支,用于处理默认情况。我们也可以用t代替otherwise,其语义是一样的:
[5] > (defun grade-meaning (grade)
        (case grade
            ((5) "Excellent")
            ((4) "Good")
            ((3) "Average")
            ((2) "Poor")
            ((1) "Failing")
            (t "Illegal grade")))

三、循环结构
和前两种控制结构相比,循环结构相对更加复杂一些。C语言提供了三种循环结构:for,do-while和while。而在Common Lisp中最通用也最灵活的循环结构为do宏。

do宏的语法形式如下:
(do ((var init-form step-form)*)
    (end-test-form result-form*)
  statement*)

和C语言中的for语句相似,do宏的执行过程也比较复杂:
1) 在初始化阶段,即循环未开始前,init-form被求值,求值结果赋给var;
2) 求值end-test-form,如果为nil,则进入子循环体,执行statement*; 如果为真,则求值result-form,并将求值结果作为do的返回值,循环结束;
3) 每个子循环执行完毕后,都会求值step-form,并用求值结果更新var;
4) 重复执行步骤2)

我们用个例子来分析一下这个执行过程,下面是一个求0到2的累加和的例子:
(do ((i 0 (1+ i))
     (sum 0 (+ sum i)))
   ((> i 2) sum))

1) 初始化:i = 0, sum = 0
2) 求值end-test-form,判断终止条件是否成立,(> 0 2)为nil,进入子循环;
3) 循环体为空,求值step-form,即i <- 0 + 1,结果i = 1; sum <- sum + i = 0 + 0(注意:这里的i用的是更新前的旧值),结果sum = 0; 
4) 求值end-test-form,判断终止条件是否成立,(> 1 2)为nil,进入子循环;
5) 循环体为空,求值step-form,即i <- 1 + 1,结果i = 2; sum <- sum + i = 0 + 1 = 1; 
6) 求值end-test-form,判断终止条件是否成立,(> 2 2)为nil,进入子循环;
7) 循环体为空,求值step-form,即i <- 2 + 1,结果i = 3; sum <- sum + i = 1 + 2 = 3; 
8) 求值end-test-form,判断终止条件是否成立,(> 3 2)为t,求值result-form,即sum = 3,do循环结束,返回值3。

do宏通用性强,但语法及行为复杂。为了简化代码,方便使用,针对两种常见情况Common Lisp基于do宏又提供了dotimes和dolist两个宏。

dotimes宏顾名思义,适用于多次重复执行某个动作,其语法形式:
(dotimes (var max-count-form)
  body-form*)

其执行流程照比do宏要简单的多,注意max-count-form求值结果必须为一数值:
1) var初始化为0
2) 检查循环结束条件:如果var小于max-count-form的求值结果,则求值body-form;否则返回nil
3) var <- var + 1
4) 重复执行步骤2)

例如:
[1] > (dotimes (i 2) (print i))
0
1
NIL

dolist宏适用于迭代处理一个list中的诸多元素,其语法形式如下:
(dolist (var list-form)
  body-form*)

其执行流程大致如下:
1) var初始化为list-form的第一个元素
2) 检查循环结束条件:如果var不为nil,则求值body-form;否则返回nil
3) var被赋值为list-form中的下一个元素
4) 重复执行步骤2)

例如:
[1]> (dolist (i '(1 2 3))
        (print (* 2 i)))
2
4
6
NIL

[2]> (defun integer-list-sum (x)
        (let ((sum 0))
            (dolist (i x)
                (setf sum (+ sum i)))
            (print sum)))
INTEGER-LIST-SUM
[3]> (integer-list-sum '(1 2 3 4))
10

在C语言中,我们可以通过break从循环中主动退出。Common Lisp同样也提供了"break"特性,不过Common Lisp用的是return,例如:

[1]> (do ((n 0 (1+ n))
          (cur 0 next)
          (next 1 (+ cur next)))
       ((= 10 n) cur)
       (if (oddp cur)
           (progn
               (print cur)
               (return))))
1
NIL

有了三种控制结构,我们就可以用Common Lisp编写出更加富有表现力的实用代码了。以上只是Common Lisp提供的标准控制结构。别忘了,Common Lisp可是一门可编程的编程语言,我们完全可以根据自己的需要定义出更加简洁方便的控制结构,不过这是高级话题了。等我们学到宏的时候再考虑这些吧。现在的首要任务就是熟练掌握这些基本的控制结构^_^。




这里是Tony Bai的个人Blog,欢迎访问、订阅和留言!订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您喜欢通过微信App浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:



本站Powered by Digital Ocean VPS。

选择Digital Ocean VPS主机,即可获得10美元现金充值,可免费使用两个月哟!

著名主机提供商Linode 10$优惠码:linode10,在这里注册即可免费获得。

阿里云推荐码:1WFZ0V立享9折!

View Tony Bai's profile on LinkedIn


文章

评论

  • 正在加载...

分类

标签

归档











更多