博客园-读来du往de猫的世界

【转载】学习C++的50忠告

斌伯 — Thu, 27 Nov 2008 17:33:00 GMT

中望的C\C++笔试给bs了，有感而发，摘录下文。虽然文章很旧了，而且其中建议有些自相矛盾，但还是可以参考参考的。

1.把C++当成一门新的语言学习（和C没啥关系！真的。）；

2.看《Thinking In C++》，不要看《C++变成死相》；
3.看《The C++ Programming Language》和《Inside The C++ Object Model》,不要因为他们很难而我们自己是初学者所以就不看；
4.不要被VC、BCB、BC、MC、TC等词汇所迷惑——他们都是集成开发环境，而我们要学的是一门语言；
5.不要放过任何一个看上去很简单的小编程问题——他们往往并不那么简单，或者可以引伸出很多知识点；
6.会用Visual C++，并不说明你会C++；
7.学class并不难，template、STL、generic programming也不过如此——难的是长期坚持实践和不遗余力的博览群书；
8.如果不是天才的话，想学编程就不要想玩游戏——你以为你做到了，其实你的C++水平并没有和你通关的能力一起变高——其实可以时刻记住：学C++是为了编游戏的；
9.看Visual C++的书，是学不了C++语言的；
10.浮躁的人容易说：XX语言不行了，应该学YY；——是你自己不行了吧！？
11.浮躁的人容易问：我到底该学什么；——别问，学就对了；
12.浮躁的人容易问：XX有钱途吗；——建议你去抢银行；
13.浮躁的人容易说：我要中文版！我英文不行！——不行？学呀！
14.浮躁的人容易问：XX和YY哪个好；——告诉你吧，都好——只要你学就行；
15.浮躁的人分两种：a)只观望而不学的人；b)只学而不坚持的人；
16.把时髦的技术挂在嘴边，还不如把过时的技术记在心里；
17.C++不仅仅是支持面向对象的程序设计语言；
18.学习编程最好的方法之一就是阅读源代码；
19.在任何时刻都不要认为自己手中的书已经足够了；
20.请阅读《The Standard C++ Bible》(中文版：标准C++宝典)，掌握C++标准；
21.看得懂的书，请仔细看；看不懂的书，请硬着头皮看；
22.别指望看第一遍书就能记住和掌握什么——请看第二遍、第三遍；
23.请看《Effective C++》和《More Effective C++》以及《Exceptional C++》；
24.不要停留在集成开发环境的摇篮上，要学会控制集成开发环境，还要学会用命令行方式处理程序；
25.和别人一起讨论有意义的C++知识点，而不是争吵XX行不行或者YY与ZZ哪个好；
26.请看《程序设计实践》，并严格的按照其要求去做；
27.不要因为C和C++中有一些语法和关键字看上去相同，就认为它们的意义和作用完全一样；
28.C++绝不是所谓的C的“扩充”——如果C++一开始就起名叫Z语言，你一定不会把C和Z语言联系得那么紧密；
29.请不要认为学过XX语言再改学C++会有什么问题——你只不过又在学一门全新的语言而已；
30.读完了《Inside The C++ Object Model》以后再来认定自己是不是已经学会了C++；
31.学习编程的秘诀是：编程，编程，再编程；
32.请留意下列书籍：《C++面向对象高效编程（C++ Effective Object-Oriented Software Construction）》《面向对象软件构造(Object-Oriented Software Construction)》《设计模式（Design Patterns）》《The Art of Computer Programming》；
33.记住：面向对象技术不只是C++专有的；
34.请把书上的程序例子亲手输入到电脑上实践，即使配套光盘中有源代码；
35.把在书中看到的有意义的例子扩充；
36.请重视C++中的异常处理技术，并将其切实的运用到自己的程序中；
37.经常回顾自己以前写过的程序，并尝试重写，把自己学到的新知识运用进去；
38.不要漏掉书中任何一个练习题——请全部做完并记录下解题思路；
39.C++语言和C++的集成开发环境要同时学习和掌握；
40.既然决定了学C++,就请坚持学下去，因为学习程序设计语言的目的是掌握程序设计技术，而程序设计技术是跨语言的；
41.就让C++语言的各种平台和开发环境去激烈的竞争吧，我们要以学习C++语言本身为主；
42.当你写C++程序写到一半却发现自己用的方法很拙劣时，请不要马上停手；请尽快将余下的部分粗略的完成以保证这个设计的完整性，然后分析自己的错误并重新设计和编写（参见43）；
43.别心急，设计C++的class确实不容易；自己程序中的class和自己的class设计水平是在不断的编程实践中完善和发展的；
44.决不要因为程序“很小”就不遵循某些你不熟练的规则——好习惯是培养出来的，而不是一次记住的；
45.每学到一个C++难点的时候，尝试着对别人讲解这个知识点并让他理解——你能讲清楚才说明你真的理解了；
46.记录下在和别人交流时发现的自己忽视或不理解的知识点；
47.请不断的对自己写的程序提出更高的要求,哪怕你的程序版本号会变成Version 100.XX；
48.保存好你写过的所有的程序——那是你最好的积累之一；
49.请不要做浮躁的人；
50.请热爱C++!

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：Google浏览器Chrome 2.0测试版发布
导航：博客园首页知识库新闻招聘社区小组博问网摘找找看

【转载】 ADS与ARX的比较

斌伯 — Sat, 22 Nov 2008 07:48:00 GMT

转载一文，来自晓东CAD家园的文章。文章详细叙述了ARX、ADS等AutoCAD二次开发接口的东西

http://www.xdcad.net/article/article/htmlcache/1709.html

　　AutoLISP是一种解释性的语言，它提供了一个简单的扩充AutoCAD命令的机制。ADS是用C语言开发的编译执行的。然而，对于AutoCAD来说，ADS程序和AutoCAD程序没有什么区别。一个ADS程序实际上是由一组外部函数组成，它们由 AutoLISP解释器来加载调用，ADS程序本身并不能直接和AutoCAD进行通讯

　　ARX程序在很多方面都和ADS程序、AutoLISP程序不同。最重要的一点是，ARX程序实质上是一个动态链接库（Dll），它和AutoCAD共享地址空间并且直接和AutoCAD进行通讯。对于经常需要和AutoCAD通讯的应用程序来说，ARX程序比 ARX运行更块。除了速度上的提高之外，ARX程序还可以创建新的类（klass），这些类可以为其它程序共享，从而充分利用面向对象编程的优点。ARX 程序创建的实体几乎和AutuCAD的内在试题是完全等同的。

　 ADS与ARX的区别：

1. ARX程序是一个动态链接库(DLL)，它直接和AutoCAD进行通讯。ADS程序是一个可执行文件，它需要通过AutoLISP来和AutoCAD进行通讯。

2. AutoCAD是不可重入的，因此ADS程序也是不可重入的。而在ARX中，每一个命令都有独立的入口。

3. ARX程序速度快，但更“脆弱”，ARX程序和AutoCAD共享进程空间，ARX程序本身是AutoCAD的一部分，ARX程序的崩溃通常会导致 AutoCAD系统的崩溃。而AutoLISP和ADS都是通过函数来间接访问AutoCAD。ADS程序速度慢，但更“绝缘”，ADS程序崩溃并不一定导致AutoCAD系统崩溃。

4. ADS程序类似如宏（macro），ADS中的函数（如ads_command）以及和AutoLISP的通讯使得ADS程序的工作类似于自动作用的宏。相比之下，ARX程序则是更基本，主程序（AutoCAD）调用每一个ARX程序注册的命令。

5. ARX程序具有ADS程序和AutoLISP程序所不具备的访问和控制AutoCAD的能力。

6. ARX提供了面向对象编程的技术。ARX充分支持C++，充分支持面向对象编程的技术，而ADS仍然只能使用传统的C语言编程。

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：微软中国被指变相裁员微软称确有过人事调整
导航：博客园首页知识库新闻招聘社区小组博问网摘找找看

【转载】比较c++中的值传递，引用传递，指针传递

斌伯 — Thu, 30 Oct 2008 08:13:00 GMT

很久没有上了，这段时间挺忙的，不过看到这篇好文章，还是转载一下，文章直截了当说明了值传递、引用传递和指针传递三者之间的不同，它厘清了三者之间模糊的边界，对理解C++是十分有益的。

原文网址：http://windshowzbf.bokee.com/2631833.html

关键词： c++ 值传递引用传递指针传递

在vc6.0下，写了个简单的程序！

在vc6.0中，File->new->SourceFile

#include "stdio.h"

#include "iostream.h"

void DeliByValue(int x);

void DeliByReference(int &x);

void DeliByPointer(int *x);

void main()

{

int number=0;

DeliByValue(number);

cout<

number=0;//重新归0

DeliByReference(number);

cout<

number=0;//重新归0

DeliByPointer(&number);

cout<

}

void DeliByValue(int x)

{

x = x+10;

}

void DeliByReference(int &x)

{

x=x+10;

}

void DeliByPointer(int *x)

{

(*x) = (*x)+10;

}

运行结果如下：0

通过这个程序进行的比较可以看出，在书写值传递，引用传递，指针传递这三个函数和调用这三个函数的区别。

林锐在《高质量c＋＋编程指南》中对此有介绍：

附上：

引用是C++中的概念，初学者容易把引用和指针混淆一起。一下程序中，n是m的一个引用（reference），m是被引用物（referent）。

int m;

int &n = m;

n相当于m的别名（绰号），对n的任何操作就是对m的操作。例如有人名叫王小毛，他的绰号是“三毛”。说“三毛”怎么怎么的，其实就是对王小毛说三道四。所以n既不是m的拷贝，也不是指向m的指针，其实n就是m它自己。

引用的一些规则如下：

（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。

（2）不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。

（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

以下示例程序中，k被初始化为i的引用。语句k = j并不能将k修改成为j的引用，只是把k的值改变成为6。由于k是i的引用，所以i的值也变成了6。

int i = 5;

int j = 6;

int &k = i;

k = j; // k和i的值都变成了6;

上面的程序看起来象在玩文字游戏，没有体现出引用的价值。引用的主要功能是传递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。

以下是“值传递”的示例程序。由于Func1函数体内的x是外部变量n的一份拷贝，改变x的值不会影响n, 所以n的值仍然是0。

void Func1(int x)

{

x = x + 10;

}

…

int n = 0;

Func1(n);

cout << “n = ” << n << endl; // n = 0

以下是“指针传递”的示例程序。由于Func2函数体内的x是指向外部变量n的指针，改变该指针的内容将导致n的值改变，所以n的值成为10。

void Func2(int *x)

{

(* x) = (* x) + 10;

}

…

int n = 0;

Func2(&n);

cout << “n = ” << n << endl; // n = 10

以下是“引用传递”的示例程序。由于Func3函数体内的x是外部变量n的引用，x和n是同一个东西，改变x等于改变n，所以n的值成为10。

void Func3(int &x)

{

x = x + 10;

}

…

int n = 0;

Func3(n);

cout << “n = ” << n << endl; // n = 10

//好好理解“值传递”“指针传递”“引用传递”（zbf）

对比上述三个示例程序，会发现“引用传递”的性质象“指针传递”，而书写方式象“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做，为什么还要“引用”这东西？

答案是“用适当的工具做恰如其分的工作”。

指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。就象一把刀，它可以用来砍树、裁纸、修指甲、理发等等，谁敢这样用？

如果的确只需要借用一下某个对象的“别名”，那么就用“引用”，而不要用“指针”，以免发生意外。比如说，某人需要一份证明，本来在文件上盖上公章的印子就行了，如果把取公章的钥匙交给他，那么他就获得了不该有的权利。

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：“新一代互联网”研究：中国走在世界前列
导航：博客园首页知识库新闻招聘社区小组博问网摘找找看

【项目】优化算法设计（三）：程序的改进的设想

斌伯 — Fri, 12 Sep 2008 11:19:00 GMT

项目程序需要改进的地方：

1.程序模块化：
     想法是把程序分为3个模块，就是3个dll咯，分别是用户界面，数据处理和优化计算。通过使程序模块化不仅可以实现用户升级，还可以给出接口让后人继续做的时候能够接上继续开发。
     程序分模块还要想到使用设计模式，这样才能使程序能够应对变化，保持稳定。变化点主要是在数据处理和优化计算之间。我考虑了一下，在装配好数据后，使用Creational Patterns创建优化计算的对象（GAOperator），具体是Factory Method 还是Builder，还没具体定下。而优化对象的结构也要进行设计来应对自身的变化，这会使用到Structural Patterns。如果还是像现在那样，选择交叉变异三算子合一的话，可以使用Bridge，它可以实现接口和具体实现的各种衍化。而李文雄老师也提出了给用户选择。他说，现在那个界面只有一个下拉菜单，可以做多几个，例如交叉算子做一个、变异算子做一个、选择算子做一个，可以让用户组合。如果真的是这样的话，就要用到Facade，使得变化的组成对客户程序是隐藏的。

2.优化算法的改进：
     改进遗传算法的问题上，李文雄老师提出要发挥遗传算法的全局搜索能力，关键就是要保持种群的多样性。要设计好一些机制，使得多样性得以维持。这就要在遗传算法的选择交叉变异三算子上下功夫。他提议可以每当新老种群交替，不要一下子就全都改变，可以在新种群中选择几个适应度低的替换旧种群，或换成随机产生的新个体。
     另为李老师还提出遗传算法运算后的结果展示有可能也改进一下。现在是用表格来显示，他希望用坐标图形来显示，做到能在优化过程中显示适应度的变化过程，就是横坐标是遗传代数，纵坐标是适应度值。这个实现起来可能很容易。我之前在vs2005使用过一个一个商业控件，给他一个DataSet设一下参数就可以出各种各样的图，包括直方图，曲线图，圈图... 我已经把各代的运算结果做成DataSet了，但现在转到vs2008来开发，不知道那个控件还能不能用。也可以是尝试自己写这样的图形控件，不过很有难度，而且时间不多了。

3.商业化的Project插件：
      就是要做好安装包，还有帮助文件的编制。安装包除了我们的程序，还要包括Office PIA和.Net Framework 3.5的打包的。帮助文件要说明一下软件原理和具体的操作。

4.使用算例显示算法优势：
      就想李东南老师的论文那样的。但他的所谓“Project有资源均衡”的优化也是有些勉强。他的做法就是把资源设置为工时类型，并设为累积计算。然后资源强度是使用一个人为100%资源使用率。当一项任务一天需要17人时，就是1700%了。而那些双代号图，资源用量图是他从Project得到结果后再用另一个软件（梦龙网络计划编制系统）一步步画出来的。早知道Project对建筑工程计划编制的支持不是很好，我就不做成Project的插件，而直接做整个软件了。我也有甘特图等那些图形控件，做起来不一定比研究Project文件结构插件做法要慢。
     我已经把他的第一个算例按我的方法做了，等到有空在把另为两个也做，到时就可以用了。

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：苏宁首战告捷销售同比增六成
导航：博客园首页   知识库   新闻   招聘   社区   小组   博问   网摘   找找看

【项目】07年度科创项目“智能施工网络优化软件开发”结题书、源代码发布

斌伯 — Fri, 12 Sep 2008 11:15:00 GMT

考虑到将结题书贴出来的话，很多图片都没了，倒不如放在网络硬盘上，有兴趣的朋友可以去下载来看看。里面包括项目的结题书和软件的源代码。代码是VS2008，C#语言的，需要配合Office Project 2003才能运行。

下载文件

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：苏宁首战告捷销售同比增六成
导航：博客园首页知识库新闻招聘社区小组博问网摘找找看

【整理】LISP简介

斌伯 — Thu, 11 Sep 2008 10:48:00 GMT

张老师一直强调AutoCAD的开发有3种接口，vba,lisp,objectarx。objectarx功能强大，但学起来比较难。而vba和lisp就相对简单了。而且到时候用objectarx作出来的程序可以轻易调用lisp，所以只要做好lisp的话，也是可以最后汇总到我们的程序里面的。他希望项目组的其它同学能够使用Visual Lisp，参与到项目的开发中。于是我特地在网上百度了一下，收集整理了一些关于Lisp的信息。信息主要来源于百度百科的数个网页。

LISP的历史

LISP（全名LIST Processor，即链表处理语言），由约翰·麦卡锡在1960年左右创造的一种基于λ演算的函数式编程语言。

Lisp 代表 LISt Processing，即表处理，这种编程语言用来处理由括号（即“(”和“)”）构成的列表。约翰麦卡锡于1960年发表了一篇非凡的论文,他在这篇论文中对编程的贡献有如欧几里德对几何的贡献.[1] 他向我们展示了,在只给定几个简单的操作符和一个表示函数的记号的基础上, 如何构造出一个完整的编程语言. 麦卡锡称这种语言为Lisp, 意为List Processing, 因为他的主要思想之一是用一种简单的数据结构表(list)来代表代码和数据.
值得注意的是,麦卡锡所作的发现,不仅是计算机史上划时代的大事, 而且是一种在我们这个时代编程越来越趋向的模式。可以说到目前为止只有两种真正干净利落, 始终如一的编程模式:C语言模式和Lisp语言模式。此二者就象两座高地, 在它们中间是尤如沼泽的低地.随着计算机变得越来越强大,新开发的语言一直在坚定地趋向于Lisp模式。二十年来,开发新编程语言的一个流行的秘诀是,取C语言的计算模式,逐渐地往上加Lisp模式的特性,例如运行时类型和无用单元收集。

LISP有很多种方言，各个实现中的语言不完全一样。1980年代Guy L. Steele编写了Common Lisp试图进行标准化，这个标准被大多数解释器和编译器所接受。在Unix/Linux系统中，还有一种和Emacs一起的Emacs Lisp（而Emacs正是用Lisp编写的）非常流行，并建立了自己的标准。
LISP的祖先是1950年代Carnegie-Mellon大学的Newell、Shaw、Simon开发的IPL语言。

LISP语言的主要现代版本包括Common Lisp和Scheme。

LISP有9大创新

直到现在，越流行语言吸收的LISP元素越多，如python,ruby。LISP直到现在仍然被众多牛人推崇。当年LISP有9大创新，50年后，深刻影响了编程语言的进程。可见一个完善的理论被适当地应用，可以变得多么强大，焕发多么夺目的生机：

1. 条件语句。当初的语言是没有if else的，goto统治世界。
2. 函数类型。函数成了语言里的类型，可以被变量指代，可以被当成参数传来传去（的一类公民的必要条件，参考SICP第一章）。这一条可以极大简化编程，让我们写出非常漂亮的程序。所以现在的流行语言纷纷加入了这个特性（可惜Java没有)。
3. 递归。这个不用说了吧。
4. 动态类型。smalltalk, python, ruby。。。连C#也有一个类似的var了。
5. 垃圾收集。不要以为GC是Smalltalk的发明哈，更不是Java的。
6. 基于表达式的编程。任何表达式都可以成为另一个表达式的一部分。不像很多语言，把表达和陈述分开。
7. 符号类型。这个在python和ruby里被采用，广受欢迎。
8. 代码即解析树。这个让LISP能方便地定义新的句法，操作程序本身，编写元程序，生成真正意义上的宏。

9. 语言无时不在。代码运行/解析可以在任何时候发生。这点和8.配合可以让语言的扩展和交流变得非常容易。

基本介绍

Lisp的表达式是一个原子(atom)或表(list)，原子(atom)是一个字母序列，如abc；表是由零个或多个表达式组成的序列，表达式之间用空格分隔开，放入一对括号中，如：
abc
()
(abc xyz)
(a b (c) d)
最后一个表是由四个元素构成的，其中第三个元素本身也是一个表。

正如算数表达式1+1有值2一样，Lisp中的表达式也有值，如果表达式e得出值v，我们说e返回v。如果一个表达式是一个表，那么我们把表中的第一个元素叫做操作符，其余的元素叫做自变量。

下面是一个在标准输出设备上输出Hello World的简单Common Lisp程序，这种程序通常作为开始学习编程语言时的第一个程序：(format t "Hello, world!~%")

Lisp的7个公理（基本操作符）：quote,atom,eq,car,cdr,cons,和 cond.

(quote x)返回x，我们简记为'x

(atom x)当x是一个原子或者空表时返回原子t，否则返回空表()。在Lisp中我们习惯用原子t表示真，而用空表()表示假。

> (atom 'a)
t
> (atom '(a b c))
()
> (atom '())
t
现在我们有了第一个需要求出自变量值的操作符，让我们来看看quote操作符的作用——通过引用(quote)一个表，我们避免它被求值。一个未被引用的表达式作为自变量，atom将其视为代码，例如：
> (atom (atom 'a))
t
反之一个被引用的表仅仅被视为表
> (atom '(atom 'a))
()

引用看上去有些奇怪，因为你很难在其它语言中找到类似的概念，但正是这一特征构成了Lisp最为与众不同的特点——代码和数据使用相同的结构来表示，而我们用quote来区分它们。

(eq x y)当x和y的值相同或者同为空表时返回t，否则返回空表()

> (eq 'a 'a)
t
> (eq 'a 'b)
()
> (eq '() '())
t

(car x)要求x是一个表，它返回x中的第一个元素，例如：

> (car '(a b))
a

(cdr x)同样要求x是一个表，它返回x中除第一个元素之外的所有元素组成的表，例如：

> (cdr '(a b c))
(b c)

(cons x y)要求y是一个表，它返回一个表，这个表的第一个元素是x，其后是y中的所有元素，例如：

> (cons 'a '(b c))
(a b c)

> (cons 'a (cons 'b (cons 'c ())))
(a b c)

(cond (...) ...(...)) 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式,相应的e表达式的值作为整个cond表达式的返回值.

> (cond ((eq 'a 'b) 'first)
((atom 'a) 'second))
second

函数的表示
当表达式以七个原始操作符中的五个开头时,它的自变量总是要求值的。我们称这样的操作符为函数。接着我们定义一个记号来描述函数。函数表示为(lambda (...) e),其中 ...是原子(叫做参数),e是表达式。如果表达式的第一个元素形式如上
((lambda (...) e) ...) 则称为函数调用。它的值计算如下，每一个表达式先求值，然后e再求值。在e的求值过程中,每个出现在e中的的值是相应的在最近一次的函数调用中的值。
> ((lambda (x) (cons x '(b))) 'a)
(a b)
> ((lambda (x y) (cons x (cdr y)))
'z
'(a b c))
(z b c)
如果一个表达式的第一个元素f是原子且f不是原始操作符 (f ...) 并且f的值是一个函数(lambda (...))，则以上表达式的值就是 ((lambda (...) e) ...) 的值。换句话说，参数在表达式中不但可以作为自变量也可以作为操作符使用:
> ((lambda (f) (f '(b c)))
'(lambda (x) (cons 'a x)))
(a b c)
有另外一个函数记号使得函数能提及它本身,这样我们就能方便地定义递归函数。记号 (label f (lambda (...) e)) 表示一个象(lambda (...) e)那样的函数，加上这样的特性: 任何出现在e中的f将求值为此label表达式，就好象f是此函数的参数。
假设我们要定义函数(subst x y z)，它取表达式x，原子y和表z做参数,返回一个象z那样的表，不过z中出现的y(在任何嵌套层次上)被x代替。
> (subst 'm 'b '(a b (a b c) d))
(a m (a m c) d)
我们可以这样表示此函数
(label subst (lambda (x y z)
(cond ((atom z)
(cond ((eq z y) x)
('t z)))
('t (cons (subst x y (car z))
(subst x y (cdr z)))))))
我们简记f=(label f (lambda (...) e))为
(defun f (...) e)
于是
(defun subst (x y z)
(cond ((atom z)
(cond ((eq z y) x)
('t z)))
('t (cons (subst x y (car z))
(subst x y (cdr z))))))
偶然地我们在这儿看到如何写cond表达式的缺省子句. 第一个元素是't的子句总是会成功的. 于是
(cond (x y) ('t z))
等同于我们在某些语言中写的
if x then y else z

一些函数
既然我们有了表示函数的方法,我们根据七个原始操作符来定义一些新的函数. 为了方便我们引进一些常见模式的简记法. 我们用cxr,其中x是a或d的序列,来简记相应的car和cdr的组合. 比如(cadr e)是(car (cdr e))的简记,它返回e的第二个元素.
> (cadr '((a b) (c d) e))
(c d)
> (caddr '((a b) (c d) e))
e
> (cdar '((a b) (c d) e))
(b)
我们还用(list ...)表示(cons ...(cons '()) ...).
> (cons 'a (cons 'b (cons 'c '())))
(a b c)
> (list 'a 'b 'c)
(a b c)
现在我们定义一些新函数. 我在函数名后面加了点,以区别函数和定义它们的原始函数,也避免与现存的common Lisp的函数冲突.

(null. x)测试它的自变量是否是空表.
(defun null. (x)
(eq x '()))
> (null. 'a)
()
> (null. '())
t

(and. x y)返回t如果它的两个自变量都是t, 否则返回().
(defun and. (x y)
(cond (x (cond (y 't) ('t '())))
('t '())))
> (and. (atom 'a) (eq 'a 'a))
t
> (and. (atom 'a) (eq 'a 'b))
()

(not. x)返回t如果它的自变量返回(),返回()如果它的自变量返回t.
(defun not. (x)
(cond (x '())
('t 't)))
> (not. (eq 'a 'a))
()
> (not. (eq 'a 'b))
t

(append. x y)取两个表并返回它们的连结.
(defun append. (x y)
(cond ((null. x) y)
('t (cons (car x) (append. (cdr x) y)))))
> (append. '(a b) '(c d))
(a b c d)
> (append. '() '(c d))
(c d)

(pair. x y)取两个相同长度的表,返回一个由双元素表构成的表,双元素表是相应位置的x,y的元素对.
(defun pair. (x y)
(cond ((and. (null. x) (null. y)) '())
((and. (not. (atom x)) (not. (atom y)))
(cons (list (car x) (car y))
(pair. (cdr) (cdr y))))))
> (pair. '(x y z) '(a b c))
((x a) (y b) (z c))

(assoc. x y)取原子x和形如pair.函数所返回的表y,返回y中第一个符合如下条件的表的第二个元素:它的第一个元素是x.
(defun assoc. (x y)
(cond ((eq (caar y) x) (cadar y))
('t (assoc. x (cdr y)))))
> (assoc. 'x '((x a) (y b)))
a
> (assoc. 'x '((x new) (x a) (y b)))
new

一个惊喜
因此我们能够定义函数来连接表,替换表达式等等.也许算是一个优美的表示法, 那下一步呢? 现在惊喜来了. 我们可以写一个函数作为我们语言的解释器:此函数取任意Lisp表达式作自变量并返回它的值. 如下所示:
(defun eval. (e a)
(cond
((atom e) (assoc. e a))
((atom (car e))
(cond
((eq (car e) 'quote) (cadr e))
((eq (car e) 'atom) (atom (eval. (cadr e) a)))
((eq (car e) 'eq) (eq (eval. (cadr e) a)
(eval. (caddr e) a)))
((eq (car e) 'car) (car (eval. (cadr e) a)))
((eq (car e) 'cdr) (cdr (eval. (cadr e) a)))
((eq (car e) 'cons) (cons (eval. (cadr e) a)
(eval. (caddr e) a)))
((eq (car e) 'cond) (evcon. (cdr e) a))
('t (eval. (cons (assoc. (car e) a)
(cdr e))
a))))
((eq (caar e) 'label)
(eval. (cons (caddar e) (cdr e))
(cons (list (cadar e) (car e)) a)))
((eq (caar e) 'lambda)
(eval. (caddar e)
(append. (pair. (cadar e) (evlis. (cdr e) a))
a)))))
(defun evcon. (c a)
(cond ((eval. (caar c) a)
(eval. (cadar c) a))
('t (evcon. (cdr c) a))))
(defun evlis. (m a)
(cond ((null. m) '())
('t (cons (eval. (car m) a)
(evlis. (cdr m) a)))))
eval.的定义比我们以前看到的都要长. 让我们考虑它的每一部分是如何工作的.
eval.有两个自变量: e是要求值的表达式, a是由一些赋给原子的值构成的表,这些值有点象函数调用中的参数. 这个形如pair.的返回值的表叫做环境. 正是为了构造和搜索这种表我们才写了pair.和assoc..
eval.的骨架是一个有四个子句的cond表达式. 如何对表达式求值取决于它的类型. 第一个子句处理原子. 如果e是原子, 我们在环境中寻找它的值:

> (eval. 'x '((x a) (y b)))
a
第二个子句是另一个cond, 它处理形如(a ...)的表达式, 其中a是原子. 这包括所有的原始操作符, 每个对应一条子句.

> (eval. '(eq 'a 'a) '())
t
> (eval. '(cons x '(b c))
'((x a) (y b)))
(a b c)
这几个子句(除了quote)都调用eval.来寻找自变量的值.
最后两个子句更复杂些. 为了求cond表达式的值我们调用了一个叫 evcon.的辅助函数. 它递归地对cond子句进行求值,寻找第一个元素返回t的子句. 如果找到了这样的子句, 它返回此子句的第二个元素.

> (eval. '(cond ((atom x) 'atom)
('t 'list))
'((x '(a b))))
list
第二个子句的最后部分处理函数调用. 它把原子替换为它的值(应该是lambda 或label表达式)然后对所得结果表达式求值. 于是

(eval. '(f '(b c))
'((f (lambda (x) (cons 'a x)))))
变为
(eval. '((lambda (x) (cons 'a x)) '(b c))
'((f (lambda (x) (cons 'a x)))))
它返回(a b c).
eval.的最后cond两个子句处理第一个元素是lambda或label的函数调用.为了对label 表达式求值, 先把函数名和函数本身压入环境, 然后调用eval.对一个内部有 lambda的表达式求值. 即:

(eval. '((label firstatom (lambda (x)
(cond ((atom x) x)
('t (firstatom (car x))))))
y)
'((y ((a b) (c d)))))
变为
(eval. '((lambda (x)
(cond ((atom x) x)
('t (firstatom (car x)))))
y)
'((firstatom
(label firstatom (lambda (x)
(cond ((atom x) x)
('t (firstatom (car x)))))))
(y ((a b) (c d)))))
最终返回a.
最后,对形如((lambda (...) e) ...)的表达式求值,先调用evlis.来求得自变量(...)对应的值(...),把()...()添加到环境里, 然后对e求值. 于是

(eval. '((lambda (x y) (cons x (cdr y)))
'a
'(b c d))
'())
变为
(eval. '(cons x (cdr y))
'((x a) (y (b c d))))
最终返回(a c d).
后果
既然理解了eval是如何工作的, 让我们回过头考虑一下这意味着什么. 我们在这儿得到了一个非常优美的计算模型. 仅用quote,atom,eq,car,cdr,cons,和cond, 我们定义了函数eval.,它事实上实现了我们的语言,用它可以定义任何我们想要的额外的函数.
当然早已有了各种计算模型--最著名的是图灵机. 但是图灵机程序难以读懂. 如果你要一种描述算法的语言, 你可能需要更抽象的, 而这就是约翰麦卡锡定义 Lisp的目标之一.
约翰麦卡锡于1960年定义的语言还缺不少东西. 它没有副作用, 没有连续执行 (它得和副作用在一起才有用), 没有实际可用的数,没有动态可视域. 但这些限制可以令人惊讶地用极少的额外代码来补救. Steele和Sussman在一篇叫做“解释器的艺术”的著名论文中描述了如何做到这点。
如果你理解了约翰麦卡锡的eval, 那你就不仅仅是理解了程序语言历史中的一个阶段. 这些思想至今仍是Lisp的语义核心. 所以从某种意义上, 学习约翰麦卡锡的原著向我们展示了Lisp究竟是什么. 与其说Lisp是麦卡锡的设计,不如说是他的发现. 它不是生来就是一门用于人工智能, 快速原型开发或同等层次任务的语言. 它是你试图公理化计算的结果(之一).

随着时间的推移, 中级语言, 即被中间层程序员使用的语言, 正一致地向Lisp靠近. 因此通过理解eval你正在明白将来的主流计算模式会是什么样.

后记：细看LISP的代码，就可以看到，正如Woodpecker.org.cn上的一个网页（http://wiki.woodpecker.org.cn/moin/Lisp，该网页有相当多的Lisp资源）所说，LISP语法解析树的前缀表达。可能是我看惯C风格的程序，一时半会还不习惯，甚至觉得这个LISP比起ObjectARX难多了。不过在这短短的数小时内，通过数个网页增进了对LISP的了解，虽然还未能消化得了，但今后还有更多深入研究的时间，希望能够把LISP的威力发挥出来。

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：福布斯：虚拟化技术登陆Mac平台
导航：博客园首页知识库新闻招聘社区小组博问网摘找找看

【转载】匈牙利表示法

斌伯 — Sun, 07 Sep 2008 11:06:00 GMT

近来学MFC，看到很多的变量命名都觉得很诡异，但又觉得其中必有一定的规律。看了该文章后才茅塞顿开，原来变量的命名也有大学问在里头。

匈牙利表示法：

它通过在每一个表示符名字的前面放置一个数据类型助记符，为程序员提供了对标识符的即时识别。

1.MFC、句柄、控件及结构的命名规则。

Windows类型	样本变量	MFC类	样本对象
HWND	hWnd	CWnd*	pWnd
HDLG	hDlg	CDialog*	pDlg
HDC	hDC	CDC*	pDC
HGDIOBJ	hGdiObj	CGdiObject*	pGdiObj
HPEN	hPen	CPen*	pPen
HBRUSH	hBrush	CBrush*	pBrush
HFONT	hFont	CFont*	pFont
HBITMAP	hBitmap	CBitmap*	pBitmap
HPALETTE	hpalette	CPalette*	pPalette
HRGN	hRgn	CRgn*	pRgn
HMENU	hMenu	CMenu*	pMenu
HWND	hCtl	CState*	pState
HWND	hCtl	CButton*	pButton
HWND	hCtl	CEdit*	pEdit
HWND	hCtl	CListBox*	pListBox
HWND	hCtl	CComboBox*	pComboBox
HWND	hCtl	CScrollBar*	pScrollBar
HSZ	hszStr	CString	pStr
POINT	pt	CPoint	pt
SIZE	size	CSize	size
RECT	rect	CRet	rect

2.一般前缀命名规范

前缀	类型	实例
C	类或结构	CDocument,CPrintInfo
m_	成员变量	m_pDoc,

3.变量名规范

前缀	类型	描述	实例
ch	char	8为字符	chGrade
ch	TCHAR	如果_UNICODE定义，为16位字符	chName
b	BOOL	布尔值	bEnabled
n	int	整型（其大小依赖于操作系统）	nLength
n	UNIT	无符号值（其大小依赖于操作系统）	nLength
w	WORD	16位无符号值	wPos
l	LONG	32位有符号整型	lOffset
dw	DWORD	32位无符号整型	dwRange
p	*	指针	pDoc
lp	FAR*	远指针	lpDoc
lpsz	LPSTR	32位字符串指针	lpszName
lpsz	LPCTSTR	如果_UNICODE定义，位32位常量字符串指针	lpszName
h	handle	Windows对象句柄	hWnd
lpfn	callback	指向CALLBACK函数的远指针	lpfnAbort

4.应用程序符号命名规范

前缀	符号类型	实例	范围
IDR_	不同类型的多个资源共享标识	IDR_MAINFRAME	1-0x6FFF
IDD_	对话框资源	IDD_SPELL_CHECK	...
HIDD_	对话框资源的Help上下文	HIDD_SPELL_CHECK	0X20001-0X26FF
IDB_	位图资源	IDB_COMPANY_LOGO	1-0X6FFF
IDC_	光标资源	IDC_PENCIL	...
IDI_	图表资源	IDI_NOTEPAD	...
ID_	来自菜单项或工具栏的命令	ID_TOOLS_SPELLING	0x8000-0xDFFF
HID_	命令Help上下文	HID_TOOLS_SPELLING	...
IDP_	消息框提示	IDP_INVALID_PARINO	8-0xDFFF
HIDP_	消息框Help上下文	HIDP_INVALID_PARINO	0X30008-0x3DFFF
IDS_	串资源	IDS_COPYRIGHT	1-0x7FFF
IDC_	对话框内的控件	IDC_RECALC	8-0xDFFF

5.Microsoft MFC宏命名规范

名称	类型
_AFXDLL	唯一的动态连接库（Dynamic
_ALPHA	仅编译DEC
_DEBUG	包括诊断的调式版本
_MBCS	编译多字节字符集
_UNICODE	在一个应用程序中打开Unicode
AFXAPI	MFC提供的函数
CALLBACK	通过指针回调的函数

6.库标识命名规范

指示符	值和含义
u	ANSI（N）或Unicodeu（U）
d	调试或发行：D=调式；忽略指示符为发行

7.静态库版本命名规范

库	描述
NAFXCWD.LIB	调试版本：MFC静态连接库
NAFXCW.LIB	发行...
UAFXCWD.LIB	调试版本：具有Unicode支持的MFC静态连接库
UAFXCW.LIB	发行...

8.动态库连接命名规范

名称	类型
_AFXDLL	唯一的动态连接库（DLL）版本
WINAPI	Windows所提供的函数

9.Windows.h命名规范

类型定义	描述
WINAPI	使用在API自己的API中使用该类型
CALLBACK	使用在应用程序回叫例程如窗口和对话框中的FAR
LPCSTR	与LPSTR相同，但LPCSTR用于只读串指针，其定义类似于（const char FAR*）
UNIT	与可移值的无符号整型类型，其大小由主机环境决定（对Windows NT和Windows 95为32位）。它是unsigned int的同义词，使用WORD位置，在一个32位的平台上希望得到一个16为无符号值的极少数情况除外
LRESULT	窗口程序返回值的类型
LPARAM	声明lParam所使用的类型，lParam 是窗口程序的第四个参数
WPARAM	声明wParam所使用的类型， wParam是窗口程序的第三个参数（一种组合数据类型）
LPVOID	一般的指针类型，与（void*）等同。应该使用它来代替LPSTR。

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：微软CEO信誓旦旦:Windows 7将成最出色操作系统
导航：博客园首页知识库新闻招聘社区小组博问网摘找找看

【转载】宏定义的经典错误

斌伯 — Thu, 24 Jul 2008 16:12:00 GMT

在百度知道中看到一则经典的宏定义错误。鉴于MFC，Windows SDK中将有很多宏定义的东西，特此记录，以作提醒。

#define S(x) x*x
int y,z=10;
y = S(z+1)

等价于
int y,z=10;
y = z+1*z+1
所以y=10+1*10+1=21

如果
#define S(x) (x)*(x)
int y,z=10;
y = S(z+1)
等价于
int y,z=10;
y = (z+1)*(z+1)
所以y=11*11=121

宏定义只是简单的文字替换，只要按照替换规则小心替换，然后求值即可

--------------------------
盛大招聘.Net开发工程师
经典好书：.NET框架程序设计（修订版）
新闻：趣闻:李开复其实是跳舞机高手
导航：博客园首页知识库新闻招聘社区小组博问网摘找找看