标签 Clisp 下的文章

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可是一门可编程的编程语言,我们完全可以根据自己的需要定义出更加简洁方便的控制结构,不过这是高级话题了。等我们学到宏的时候再考虑这些吧。现在的首要任务就是熟练掌握这些基本的控制结构^_^。

C程序员驯服Common Lisp – 表达式

Common Lisp程序由一组表达式构成。在"入门"一文中我提到过:Common Lisp使用S-expressions作为表达式(Expressions)的基本语法格式。S-expressions由原子(atoms)和S-expressions列表组成,或者说原子和列表(List)是组成S-expression的基本元素。复杂的源程序都是由简单的表达式组成的,我们在学习编写实用的Common Lisp程序之前,首先要清楚简单表达式的结构和求值方法。

每个Lisp表达式都可以提交给Common Lisp解释器进行求值,并得到一个求值结果。这里我们从简单的原子说起。

一、原子
原子虽然十分简单,但它也是一种表达式。对于原子而言,其求值结果就是其自身的值。下面我们来看看一些常见的原子以及其求值结果:

(1) 数字(Number)
数字是一种原子,其求值结果即为其自身数值。

* 整型数字
[1]> 13
13
[2]> -4
-4
[3]> 0
0
[4]> #xa    ;; 16进制数
10
[5]> #o11   ;; 8进制数
9
[6]> #b011  ;; 二进制数
3
[7]> #24r1n ;; 24进制数
47

最后的#24r1n是一种通用N进制数表示形式,N取值范围为2到36,其表示形式为#Nr…。

* 浮点数
[1]> 3.1415
13
[2]> 365e0
365.0
[3]> 365e-3
0.365
[4]> 365f-3
0.365
[5]> 365d-3
0.365d0
[6]> 0.365e20
3.65E19

标志f表示单精度浮点数,标志d表示双精度浮点数,标志e表示默认采用单精度,与f相同。

* 分数
[1]> 5/6
5/6

* 复数
[1]> #C(1.2 3)
#C(1.2 3)

C(1.2 3)对应的复数为1.2+3i。

(2) 字符(character)
单独的字符也是原子,其求值结果也是其自身值。

下面是一些可见字符:
[1]> #\a
#\a
[2]> #\A
#\A
[3]> #\%
#\%
[4]> #\&
#\&

一些常见的控制字符的形式如下:
[1]> #\newline
#\Newline
[2]> #\tab
#\Tab
[3]> #\backspace
#\Backspace
[4]> #\space
#\Space
[5]> #\escape
#\Escape

(3) 字符串(string)
C语言中的字符串不同,Common lisp中字符串结尾并不包含''。但字符串也是原子,其求值结果依旧是其本身。

[1]> "Hello, Common Lisp!"
"Hello, Common Lisp!"

我们可以字符转义将一些特殊字符放入字符串,比如我们可以在字符串中包含双引号:
[2]> (format t "~A ~%" "He said \"I am going to see Harry Potter!\" and then he left.")
He said "I am going to see Harry Potter!" and then he left.
NIL

不过我们无法通过转义方法将tab字符、回车符、换行符放入字符串,只能通过键盘手工输入:
[3]> "Look, here are      tabs      and some

returns!

Understand?"
"Look, here are      tabs      and some

returns!

Understand?"

(4) 布尔类型(bool)
布尔值也是原子,但只有两个可选值:t和nil。t代表true,nil代表false,由于比较简单,这里就不细说了。

(5) 符号(symbols)
C语言不同的是,Common Lisp中有一种语法元素称为"符号"。符号有些类似于C语言中的标识符,用来表示Lisp程序中使用的名字,诸如函数和变量的名字,像format,hello-foo, *counter*等。Lisp符号的包容性更强,像+,-等在C中为操作符关键字的字符都可以作为符号。

(a b c)       ; 一个包含三个符号的list
(a 2 "bar")   ; 这个list包含一个符号,一个数字和一个字符串
(+ (* 2 3) 4) ; 这个list包含一个符号,一个列表以及一个数字

符号的求值比较特殊,如果该符号没有绑定到任何值,解释器会提示错误。如果绑定了值,则显示绑定的值:
[1]> a

*** – EVAL: variable A has no value
The following restarts are available:
USE-VALUE      :R1      You may input a value to be used instead of A.
STORE-VALUE    :R2      You may input a new value for A.
ABORT          :R3      Abort main loop
Break 1 [2]> :r3
[3]> (setf a 5)
5
[4]> a
5

二、列表
在实用程序中,我们很少将原子单独作为表达式,我们更多使用的是List,即列表。之前说过Common Lisp的核心就是List,此List不同于我们以往数据结构中学习的那个List,在Common Lisp中,List是程序和数据的载体,别忘了Lisp是"LISt Processing"的缩写,直译过来Lisp就是List处理语言,这也凸显了List在Lisp语言中的核心地位。

绝大多数情况下,Lisp程序字面上就是一组列表集合。掌握对List进行求值的方法就显得尤为重要了。

我们先从一个简单到不能再简单的List入手:
[1]> (+ 1 2)
3

这个List由三个原子组成,一个符号以及两个数字。Common Lisp解释器会首先检查第一个元素是否是一个符号并且是否是一个绑定了有效函数的符号。如果不符合条件则报错。如果第一个元素是符号且绑定合法函数,如+,那么解释器会将后续的元素作为该函数的参数,并自左向右对参数逐个进行求值。

[1]> (length "hello lisp")
10
[2]> ("foo" 1 2)

*** – EVAL: "foo" is not a function name; try using a symbol instead
The following restarts are available:
USE-VALUE      :R1      You may input a value to be used instead.
ABORT          :R2      Abort main loop

在(+ 1 2)这个例子中,+是一个符合条件的符号,解释器接下来对1和2这两个原子进行求值,前面提到整数是原子,其求值结果即为自身值,所以解释器将1和2传给+,得到最终结果3。

Common Lisp的解释器对参数的求值是自左向右递归进行的,下面是一个稍复杂的表达式,其详细的求值过程如下:

(+ (- 7 (/ 4 2)) (* 3 4))
-> (+ (- 7 2) (* 3 4))
-> (+ 5 (* 3 4))
-> (+ 5 12)
-> 17

解释器从左向右依次对参数进行求值,解释器遇到函数+的第一个参数(- 7 (/ 4 2)),这显然是也是一个减法表达式,解释器递归地对该表达式进行求值;(- 7 (/ 4 2))表达式的第一个参数7为原子类型,其求值结果为自身值7;第二个参数又是一个除法表达式,解释器再一次进行递归求值,进入(/ 4 2),这是个简单表达式,其求值结果为2;求值程序回到表达式(- 7 2),得到求值结果5,至此最外层表达式的第一个参数求值完毕,结果为5;解释器继续对最外层表达式的第二个参数(* 3 4)进行求值,这是个乘法表达式,对该表达式求值结果为12,这样我们的顶层表达式就变成了(+ 5 12),则最终求值结果就为17。这个过程有点类似于树遍历算法中的深度优先遍历算法。

无论是多么复杂的表达式,Common Lisp解释器的求值方法都是如此的。当然解释器不一定会将函数的所有参数都进行求值,比如:(if t 5 (+ 6 7)这个表达式在if条件为t时,只会求值5这个参数,(+ 6 7)这个表达式不会被求值。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

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

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

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats