第3章我编写过的最漂亮的代码
Jon Bentley
我曾经听一位大师级的程序员这样称赞到，“我通过删除代码来实现功能的提升。”而法国著名作家兼飞行家Antoine de Saint-Exupéry的说法则更具代表性，“只有在不仅没有任何功能可以添加，而且也没有任何功能可以删除的情况下，设计师才能够认为自己的工作已臻完美。”某些时候，在软件中根本就不存在最漂亮的代码，最漂亮的函数，或者最漂亮的程序。
当然，我们很难对不存在的事物进行讨论。本章将对经典Quicksort（快速排序）算法的运行时间进行全面的分析，并试图通过这个分析来说明上述观点。在第一节中，我将首先根据我自己的观点来回顾一下Quicksort，并为后面的内容打下基础。第二节的内容将是本章的重点部分。我们将首先在程序中增加一个计数器，然后通过不断地修改，从而使程序的代码变得越来越短，但程序的功能却会变得越来越强，最终的结果是只需要几行代码就可以使算法的运行时间达到平均水平。在第三节将对前面的技术进行小结，并对二分搜索树的运行开销进行简单的分析。最后的两节将给出学完本章得到的一些启示，这将有助于你在今后写出更为优雅的程序。
3.1 我编写过的最漂亮代码
当Greg Wilson最初告诉我本书的编写计划时，我曾自问编写过的最漂亮的代码是什么。这个有趣的问题在我脑海里盘旋了大半天，然后我发现答案其实很简单：Quicksort算法。但遗憾的是，根据不同的表达方式，这个问题有着三种不同的答案。
当我撰写关于分治（divide-and-conquer）算法的论文时，我发现 C.A.R. Hoare的Quicksort算法（“Quicksort”，Computer Journal 5）无疑是各种Quicksort算法的鼻祖。这是一种解决基本问题的漂亮算法，可以用优雅的代码实现。我很喜欢这个算法，但我总是无法弄明白算法中最内层的循环。我曾经花两天的时间来调试一个使用了这个循环的复杂程序，并且几年以来，当我需要完成类似的任务时，我会很小心地复制这段代码。虽然这段代码能够解决我所遇到的问题，但我却并没有真正地理解它。
我后来从Nico Lomuto那里学到了一种优雅的划分（partitioning）模式，并且最终编写出了我能够理解，甚至能够证明的Quicksort算法。William Strunk Jr.针对英语所提出的“良好的写作风格即为简练”这条经验同样适用于代码的编写，因此我遵循了他的建议，“省略不必要的字词”（来自《The Elements of Style》一书）。我最终将大约40行左右的代码缩减为十几行的代码。因此，如果要回答“你曾编写过的最漂亮代码是什么？”这个问题，那么我的答案就是：在我编写的《Programming Pearls, Second Edition》(Addison-Wesley)一书中给出的Quichsort算法。在示例3-1中给出了用C语言编写的Quicksort函数。我们在接下来的章节中将进一步地研究和改善这个函数。
【示例】 3-1 Quicksort函数
void quicksort(int l, int u)
{ int i, m;
if (l >= u) return;
swap(l, randint(l, u));
m = l;
for (i = l+1; i <= u; i++)
if (x[i] < x[l])
swap(++m, i);
swap(l, m);
quicksort(l, m-1);
quicksort(m+1, u);
}
如果函数的调用形式是quicksort(0, n-1)，那么这段代码将对一个全局数组x[n]进行排序。函数的两个参数分别是将要进行排序的子数组的下标：l是较低的下标，而u是较高的下标。函数调用swap(i,j)将会交换x[i]与x[j]这两个元素。第一次交换操作将会按照均匀分布的方式在l和u之间随机地选择一个划分元素。
在《Programming Pearls》一书中包含了对Quicksort算法的详细推导以及正确性证明。在本章的剩余内容中，我将假设读者熟悉在《Programming Pearls》中所给出的Quicksort 算法以及在大多数初级算法教科书中所给出的Quicksort算法。
如果你把问题改为“在你编写那些广为应用的代码中，哪一段代码是最漂亮的？”我的答案还是Quicksort算法。在我和M. D. McIlroy一起编写的一篇文章（"Engineering a sort function," Software-Practice and Experience, Vol. 23, No. 11）中指出了在原来Unix qsort函数中的一个严重的性能问题。随后，我们开始用C语言编写一个新排序函数库，并且考虑了许多不同的算法，包括合并排序（Merge Sort）和堆排序（Heap Sort）等算法。在比较了Quicksort的几种实现方案后，我们着手创建自己的Quicksort算法。在这篇文章中描述了我们如何设计出一个比这个算法的其他实现要更为清晰，速度更快以及更为健壮的新函数——部分原因是由于这个函数的代码更为短小。Gordon Bell的名言被证明是正确的：“在计算机系统中，那些最廉价，速度最快以及最为可靠的组件是不存在的。”现在，这个函数已经被使用了10多年的时间，并且没有出现任何故障。
考虑到通过缩减代码量所得到的好处，我最后以第三种方式来问自己在本章之初提出的问题。“你没有编写过的最漂亮代码是什么？”。我如何使用非常少的代码来实现大量的功能？答案还是和Quicksort有关，特别是对这个算法的性能分析。我将在下一节给出详细介绍。
3.2 事倍功半
Quicksort是一种优雅的算法，这一点有助于对这个算法进行细致的分析。大约在1980年左右，我与Tony Hoare曾经讨论过Quicksort算法的历史。他告诉我，当他最初开发出Quicksort时，他认为这种算法太简单了，不值得发表，而且直到能够分析出这种算法的预期运行时间之后，他才写出了经典的“Quicksoft”论文。
我们很容易看出，在最坏的情况下，Quicksort可能需要n2的时间来对数组元素进行排序。而在最优的情况下，它将选择中值作为划分元素，因此只需nlgn次的比较就可以完成对数组的排序。那么，对于n个不同值的随机数组来说，这个算法平均将进行多少次比较？
Hoare对于这个问题的分析非常漂亮，但不幸的是，其中所使用的数学知识超出了大多数程序员的理解范围。当我为本科生讲授Quicksort算法时，许多学生即使在费了很大的努力之后，还是无法理解其中的证明过程，这令我非常沮丧。下面，我们将从Hoare的程序开
始讨论，并且最后将给出一个与他的证明很接近的分析。
我们的任务是对示例3-1中的Quicksort代码进行修改，以分析在对元素值均不相同的数组进行排序时平均需要进行多少次比较。我们还将努力通过最短的代码、最短运行时间以及最小存储空间来得到最深的理解。
为了确定平均比较的次数，我们首先对程序进行修改以统计次数。因此，在内部循环进行比较之前，我们将增加变量comps的值（参见示例3-2）。
【示例3-2】修改Quicksort的内部循环以统计比较次数。
for (i = l+1; i <= u; i++) {
comps++;
if (x[i] < x[l])
swap(++m, i);
}
如果用一个值n来运行程序，我们将会看到在程序的运行过程中总共进行了多少次比较。如果重复用n来运行程序，并且用统计的方法来分析结果，我们将得到Quicksort在对n个元素进行排序时平均使用了1.4 nlgn次的比较。
在理解程序的行为上，这是一种不错的方法。通过十三行的代码和一些实验可以反应出许多问题。这里，我们引用作家Blaise Pascal和T. S. Eliot的话，“如果我有更多的时间，那么我给你写的信就会更短。”现在，我们有充足的时间，因此就让我们来对代码进行修改，并且努力编写出更短（同时更好）的程序。
我们要做的事情就是提高这个算法的速度，并且尽量增加统计的精确度以及对程序的理解。由于内部循环总是会执行u-l次比较，因此我们可以通过在循环外部增加一个简单的操作来统计比较次数，这就可以使程序运行得更快一些。在示例3-3的Quicksort算法中给出了这个修改。
【示例3-3】 Quicksort的内部循环，将递增操作移到循环的外部
comps += u-l;
for (i = l+1; i <= u; i++)
if (x[i] < x[l])
swap(++m, i);
这个程序会对一个数组进行排序，同时统计比较的次数。不过，如果我们的目标只是统计比较的次数，那么就不需要对数组进行实际地排序。在示例3-4中去掉了对元素进行排序的“实际操作”，而只是保留了程序中各种函数调用的“框架”。
【示例3-4】将Quicksort算法的框架缩减为只进行统计
void quickcount(int l, int u)
{ int m;
if (l >= u) return;
m = randint(l, u);
comps += u-l;
quickcount(l, m-1);
quickcount(m+1, u);
}
这个程序能够实现我们的需求，因为Quichsort在选择划分元素时采用的是“随机”方式，并且我们假设所有的元素都是不相等的。现在，这个新程序的运行时间与n成正比，并且相对于示例3-3需要的存储空间与n成正比来说，现在所需的存储空间缩减为递归堆栈的大小，即存储空间的平均大小与lgn成正比。
虽然在实际的程序中，数组的下标（l和u）是非常重要的，但在这个框架版本中并不重要。因此，我们可以用一个表示子数组大小的整数(n)来替代这两个下标（参见示例3-5）【示例3-5】在Quicksort代码框架中使用一个表示子数组大小的参数
void qc(int n)
{ int m;
if (n <= 1) return;
m = randint(1, n);
comps += n-1;
qc(m-1);
qc(n-m);
}
现在，我们可以很自然地把这个过程整理为一个统计比较次数的函数，这个函数将返回在随机Quicksort算法中的比较次数。在示例3-6中给出了这个函数。
【示例3-6】将Quicksort框架实现为一个函数
int cc(int n)
{ int m;
if (n <= 1) return 0;
m = randint(1, n);
return n-1 + cc(m-1) + cc(n-m);
}
在示例3-4、示例3-5和示例3-6中解决的都是相同的基本问题，并且所需的都是相同的运行时间和存储空间。在后面的每个示例都对这些函数的形式进行了改进，从而比这些函数更为清晰和简洁。
在定义发明家的矛盾（inventor's paradox）(How To Solve It, Princeton University Press)时，George Póllya指出“计划越宏大，成功的可能性就越大。”现在，我们就来研究在分析Quicksort时的矛盾。到目前为止，我们遇到的问题是，“当Quicksort对大小为n的数组进行一次排序时，需要进行多少次比较？”我们现在将对这个问题进行扩展，“对于大小为n的随机数组来说，Quichsort算法平均需要进行多少次的比较？”我们通过对示例3-6进行扩展以引出示例3-7。
【示例3-7】伪码：Quicksort的平均比较次数
float c(int n)
if (n <= 1) return 0
sum = 0
for (m = 1; m <= n; m++)
sum += n-1 + c(m-1) + c(n-m)
return sum/n
如果在输入的数组中最多只有一个元素，那么Quichsort将不会进行比较，如示例3-6
中所示。对于更大的n，这段代码将考虑每个划分值m（从第一个元素到最后一个，每个都是等可能的）并且确定在这个元素的位置上进行划分的运行开销。然后，这段代码将统计这些开销的总和（这样就递归地解决了一个大小为m-1的问题和一个大小为n-m的问题），然后将总和除以n得到平均值并返回这个结果。
如果我们能够计算这个数值，那么将使我们实验的功能更加强大。我们现在无需对一个n值运行多次来估计平均值，而只需一个简单的实验便可以得到真实的平均值。不幸的是，实现这个功能是要付出代价的：这个程序的运行时间正比于3n（如果是自行参考（self-referential）的，那么用本章中给出的技术来分析运行时间将是一个很有趣的练习）。
示例3-7中的代码需要一定的时间开销，因为它重复计算了中间结果。当在程序中出现这种情况时，我们通常会使用动态编程来存储中间结果，从而避免重复计算。因此，我们将定义一个表t[N+1]，其中在t[n]中存储c[n]，并且按照升序来计算它的值。我们将用N来表示n的最大值，也就是进行排序的数组的大小。在示例3-8中给出了修改后的代码。【示例3-8】在Quicksort中使用动态编程来计算
t[0] = 0
for (n = 1; n <= N; n++)
sum = 0
for (i = 1; i <= n; i++)
sum += n-1 + t[i-1] + t[n-i]
t[n] = sum/n
这个程序只对示例3-7进行了细微的修改，即用t[n]来替换c(n)。它的运行时间将正比于N2，并且所需的存储空间正比于N。这个程序的优点之一就是：在程序执行结束时，数组t中将包含数组中从元素0到元素N的真实平均值（而不是样本均值的估计）。我们可以对这些值进行分析，从而生成在Quichsort算法中统计比较次数的计算公式。
我们现在来对程序做进一步的简化。第一步就是把n-1移到循环的外面，如示例3-9所示。
【示例3-9】在Quicksort中把代码移到循环外面来计算
t[0] = 0
for (n = 1; n <= N; n++)
sum = 0
for (i = 1; i <= n; i++)
sum += t[i-1] + t[n-i]
t[n] = n-1 + sum/n
现在将利用对称性来对循环做进一步的调整。例如，当n为4时，内部循环计算总和为：t[0]+t[3] + t[1]+t[2] + t[2]+t[1] + t[3]+t[0]
在上面这些组对中，第一个元素增加而第二个元素减少。因此，我们可以把总和改写为：2 * (t[0] + t[1] + t[2] + t[3])
我们可以利用这种对称性来得到示例3-10中的Quicksort。
【示例3-10】在Quichsort中利用了对称性来计算
t[0] = 0
sum = 0
for (i = 0; i < n; i++)
sum += 2 * t[i]
t[n] = n-1 + sum/n
然而，在这段代码的运行时间中同样存在着浪费，因为它重复地计算了相同的总和。此时，我们不是把前面所有的元素加在一起，而是在循环外部初始化总和并且加上下一个元素，如示例3-11所示。
【示例3-11】在Quicksort中删除了内部循环来计算
sum = 0; t[0] = 0
for (n = 1; n <= N; n++)
sum += 2*t[n-1]
t[n] = n-1 + sum/n
这个小程序确实很有用。程序的运行时间与N成正比，对于每个从1到N的整数，程序将生成一张Quicksort的估计运行时间表。
我们可以很容易地把示例3-11用表格来实现，其中的值可以立即用于进一步的分析。在3-1给出了最初的结果行。
表3-1 示例3-11中实现的表格输出
N Sum t[n]
0 0 0
1 0 0
2 0 1
3 2 2.667
4 7.333 4.833
5 17 7.4
6 31.8 10.3
7 52.4 13.486
8 79.371 16.921
这张表中的第一行数字是用代码中的三个常量来进行初始化的。下一行（输出的第三行）的数值是通过以下公式来计算的：
A3 = A2+1 B3 = B2 + 2*C2 C3 = A3-1 + B3/A3
把这些（相应的）公式记录下来就使得这张表格变得完整了。这张表格是“我曾经编写的最漂亮代码”的很好的证据，即使用少量的代码完成大量的工作。
但是，如果我们不需要所有的值，那么情况将会是什么样？如果我们更希望通过这种来方式分析一部分数值（例如，在20到232之间所有2的指数值）呢？虽然在示例3-11中构建了完整的表格t，但它只需要使用表格中的最新值。因此，我们可以用变量t的定长空间来替代table t[]的线性空间，如示例3-12所示。
【示例3-12】 Quicksoft 计算——最终版本
sum = 0; t = 0
sum += 2*t
t = n-1 + sum/n
然后，我们可以插入一行代码来测试n的适应性，并且在必要时输出这些结果。
这个程序是我们漫长学习旅途的终点。通过本章所采用的方式，我们可以证明Alan Perlis的经验是正确的：“简单性并不是在复杂性之前，而是在复杂性之后” ("Epigrams on Programming," Sigplan Notices, Vol. 17, Issue 9)。
3.3 观点
在表3-2中总结了本章中对Quicksort进行分析的程序。
表 3-2 对Quicksort比较次数的统计算法的评价
在我们对代码的每次修改中，每个步骤都是很直接的；不过，从示例3-6中样本值到示例3-7中准确值的过渡过程可能是最微妙的。随着这种方式进行下去，代码变得更快和更有用，而代码量同样得到了缩减。在19世纪中期，Robert Browning指出“少即是多（less is more）”，而这张表格正是一个证明这种极少主义哲学（minimalist philosophy）的实例。
我们已经看到了三种截然不同的类型的程序。示例3-2和示例3-3是能够实际使用的Quicksort，可以用来在对真实数组进行排序时统计比较次数。示例3-4到示例3-6都实现了Quicksort的一种简单模型：它们模拟算法的运行，而实际上却没有做任何排序工作。从示例3-7到示例3-12则实现了一种更为复杂的模型：它们计算了比较次数的真实平均值而没有跟踪任何单次的运行。
我们在下面总结了实现每个程序所使用的技术：
* 示例3-2，示例3-4，3-7:对问题的定义进行根本的修改。
* 示例3-5，示例3-6，3-12：对函数的定义进行轻微的修改
* 示例3-8：实现动态编程的新数据结构
这些技术都是非常典型的。我们在简化程序时经常要发出这样的疑问，“我们真正要解
决的问题是什么？”或者是，“有没有更好的函数来解决这个问题？”
当我把这个分析过程讲授给本科生时，这个程序最终被缩减成零行代码，化为一阵数学的轻烟消失了。我们可以把示例3-7重新解释为以下的循环关系：
00=C ∑≤≤--++-=n
i i n i n C C n n C 11)/1()1(
这正是Hoare 所采用的方法，并且后来由D.E.Knuth 在他经典的《The Art of Computer Programming 》（Addison-Wesley ）一书的第三卷：排序与查找中给出的方法中给出了描述。通过重新表达编程思想的技巧和在示例3-10中使用的对称性，使我们可以把递归部分简化为：
∑-≤≤+-=10)
/2(1n i i n C n n C
Knuth 删除了求和符号，从而引出了示例3-11，这可以被重新表达为一个在两个未知量之间有着两种循环关系的系统：
00=C 00=S 112--+=n n n C S S n S n C n n /1+-=
Knuth 使用了“求和因子”的数学方法来实现这种解决方案：
n n H n C n n n lg 386.1~2)22)(1(1--+=+
其中n H 表示第n 个调和数（harmonic number ），即1 + 1/2 + 1/3 + … 1/n。这样，我们就从对程序不断进行修改以得到实验数据顺利地过渡到了对程序行为进行完全的数学分析。
在得到这个公式之后，我们就可以结束我们的讨论。我们已经遵循了Einstein 的著名建议：“尽量使每件事情变得简单，并且直到不可能再简单为止。”
附加分析
Goethe 的著名格言是：“建筑是静止的音乐”。按照这种说法，我可以说“数据结构是静止的算法。”如果我们固定了Quichsort 算法，那么就将得到了一个二分搜索树的数据结构。在Knuth 发表的文章中给出了这个结构并且采用类似于在Quichsort 中的循环关系来分析它的运行时间。
如果要分析把一个元素插入到二分搜索树中的平均开销，那么我们可以以这段代码作为起点，并且对这段代码进行扩展来统计比较次数，然后在我们收集的数据上进行实验。接下来，我们可以仿照前面章节中的方式来简化代码。一个更为简单的解决方案就是定义一个新的Quichsort ，在这个算法中使用理想的划分算法把有着相同关联顺序的元素划分到两边。Quichsort 和二分搜索树是同构的，如图3-1所示。
图3-1 实现理想划分的Quicksort 以及相应的二分搜索树
左边的方框给出了正在进行中的理想划分的Quicksort，右边的图则给出了相应的从相同输入中构建起来的二分搜索树。这两个过程不仅需要进行相同次数的比较，而且还将生成相同的比较集合。通过在前面对于在一组不同元素上进行Quicksort实验的平均性能分析，我们就可以得到将不同的元素随机插入到二分搜索树中的平均比较次数。
3.4 本章的中心思想是什么？
表面上看来，我“所写的”内容就是从示例3-2到示例3-12的程序。我最初是漫不经心地编写这些程序，然后将这些程序写在给本科生讲课的黑板上，并且最终写到本章中。我有条不紊地进行着这些程序的修改，并且花了大量的时间来分析这些程序，从而确信它们都是正确的。然而，除了在示例3-11中实现的表格外，我从来没有把任何一个示例作为计算机程序运行过。
我在贝尔实验室呆了将近二十年，我从许多教师（尤其是Brian Kernighan，他所编写的编程内容作为本书的第1章）那里学到了：要“编写”一个在大众面前展示的程序，所涉及到的东西比键入这个程序要多得多。有人用代码实现了这个程序，最初运行在一些测试示例中，然后构建了完整的系统框架、驱动程序以及一个案例库来支撑这段代码。理想的情况是，人们可以手动地把编译后的代码包含到文本中，不加入任何的人为干涉。基于这种想法，我编写了示例3-1（以及在《Programming Pearls》中的所有代码）。
为了维护面子，我希望永远都不要实现从示例3-2到示例3-12的代码，从而使我保持诚实的名声。然而，在计算机编程中的近四十年的实践使我对这个任务的困难性有着深深的敬畏（好吧，更准确地说，是对于错误的害怕）。我妥协了，把示例3-11用表格方式实现出来，并且无意中得到了一个完备的解答。当这两个东西完美地匹配在一起时，你可以想象一下我当时的喜悦吧！因此，我向世界提供了这些漂亮的并且未曾实现的程序，虽然在这些程序中可能会有一些还未发现的错误，但我对这些程序的正确性还是有一定信心的。我希望一些细微的错误不会掩盖我在这些程序中所展示的那些漂亮思想。
当我为给出这些没有被实现过的程序感到不安时，Alan Perlis的话安慰了我，他说“软件是不是不像任何一个事物，它就是意味着被抛弃：软件的所有意义就是把它看作为一个肥皂泡？”
3.5 结论
漂亮的含义有着许多来源。本章通过简化、优雅以及精简来刻画了漂亮的含义。下面这
些名言表达的是同样的意思：
* 通过删除代码来实现功能的提升。
* 只有在不仅没有任何功能可以添加，而且也没有任何功能可以删除的情况下，设计师才能够认为自己的工作已臻完美。
* 有时候，在软件中根本就不存在最漂亮的代码，最漂亮的函数，或者最漂亮的程序。
* 良好的写作风格即为简练。省略不必要的字词。 (Strunk and White)
* 在计算机系统中，那些最廉价、速度最快以及最为可靠的组件是不存在的（Bell）* 努力做到事倍功半。
* 如果我有更多的时间，那么我给你写的信就会越短（Pascal）
* 发明家的矛盾：计划越宏大，成功的可能性就越大。（Pólya）
* 简单性并不是在复杂性之前，而是在复杂性之后（Perlis）
* 少即是多。（Browning）
* 尽量使每件事情变得简单，并且直到不可能再简单为止（Einstein）
* 软件有时候应该被视作为一个肥皂泡（Perlis）
* 在简单中寻找漂亮。
本章的内容到此结束。读者可以复习所学到的内容并进行模拟实验。
对于那些想要得到更具体信息的人们，我在下面给出了一些观点，这些观点分为三类
程序分析
深入理解程序行为的方式之一就是修改这个程序，然后在具有代表性的数据上运行这个程序，就像示例3-2那样。不过，我们通常会更关心程序的某个方面而不是程序的整体。例如，我们只是考虑Quichsort所使用的平均比较次数，而忽略了其他的方面。Sedgewick ("The analysis of Quicksort programs," Acta Informatica, Vol. 7)研究了Quichsort的其他特性，例如算法所需的存储空间以及各种Quicksort运行时间的其他方面。我们可以关注这些关键问题，而暂时）忽略了程序其他不太重要的方面。在我的一篇文章"A Case Study in Applied Algorithm Design" (IEEE Computer, Vol. 17, No. 2)中指出了我曾经遇到过的一个问题：对在单元空间中找出货郎行走路线的strip启发式算法的性能进行评价。我估计完成这个任务所要的程序大概在100行代码左右。在经历了一系列类似于本章前面看到的分析步骤之后，我只使用了十几行代码的模拟算法就实现了更为精确的效果（在我写完了这个模拟算法后，我发现Beardwood 等人["The Shortest Path Through Many Points," Proc. Cambridge Philosophical Soc., Vol. 55]已经更完整地表述了我的模拟算法，因此已经在二十几年前就从数学上解决了这个问题）。
小段代码
我相信计算机编程是一项实践性的技术，并且我也同意这个观点：“任何技术都必须通过模仿和实践来掌握。”因此，想要编写漂亮代码的程序员应该阅读一些漂亮的程序以及在编写程序时模仿所学到的技术。我发现在实践时有个非常有用的东西就是小段代码，也就是一二十行的代码。编写《Programming Pearls》这本书是一件艰苦的工作，但同时也有着极大的乐趣。我实现了每一小段代码，并且亲自把每段代码都分解为基本的知识。我希望其他人在阅读这些代码时与我在编写这些代码时有着同样的享受过程。
软件系统
为了有针对性，我极其详尽地描述了一个小型任务。我相信其中的这些准则不仅存在于小型程序中，它们同样也适用于大型的程序以及计算机系统。Parnas（"Designing software for ease of extension and contraction," IEEE T. Software Engineering, Vol. 5, No. 2）给出了把一个系统拆分为基本构件的技术。为了得用快速的应用性，不要忘了Tom Duff 的名言：“在尽可能的情况下，利用现有的代码。”
3.6 致谢
非常感谢Dan Bentley, Brian Kernighan, Andy Oram和David Weiss卓有见识的评语。
简单计算器代码 package calcultorthree; import java.awt.BorderLayout;//导入边界布局管理器类 import java.awt.GridLayout;//导入网格布局管理器类 import java.awt.TextField;//导入文本区域类 import java.awt.event.ActionEvent;//导入事件类 import java.awt.event.ActionListener;//导入事件监听者类 import javax.swing.JButton;//导入按钮类 import javax.swing.JFrame;//导入窗体 import javax.swing.JPanel;//导入面板 /** *本例实现了简单计算器代码，具备加减乘除和正弦功能，旨在抱砖引玉。熟悉java的同学，可以在此基础上实现更复杂的功能。 * @author Fjsh */ public class CalcultorThree { //新建对象，在构造函数中进行初始化 JFrame frame;//新建窗体对象 JButton buttonzero,buttondot,buttonequal;//新建按钮“0”“.”“=” JButton buttonplus,buttonminus,buttonmultiple,buttondevision, buttonsin,buttontozero;//新建按钮“+”“-”“*”“/”“sin”和归零按钮JButton buttonone,buttontwo,buttonthree,buttonfour,buttonfive,buttonsix, buttonseven,buttoneight,buttonnine;//新建数字按钮“0”“1”“2”“3”“4”“5”“6”“7”“8”“9” JPanel panelwest,panelcenter,paneleast;//新建三个面板 TextField tf;//新建文本区域对象 public CalcultorThree(){ //初始化对象 tf=new TextField(30);//构造空文本字段，字符宽度为30 frame =new JFrame("CalculatorThree");//构造窗体对象，名称为“CalculatorThree”
一、实验目的 通过在实验二的基础上，增加中间代码生成部分，使程序能够对实验二中的识别出的赋值语句，if语句和while语句进行语义分析，生成四元式中间代码。 二、实验方法 实验程序由c语言完成，在Turboc 2.0环境中调试通过。 语义分析程序的基本做法是对文法中的每个产生式分别编写一个语义分析子程序，当程序语法部分进行推倒或规约时，就分别调用各自的语义分析程序。当语法分析结束时，语义分析也就结束了。 在本实验程序中，当语法分析部分识别出语确的句子时，就进入content函数（当语法分析识别出不正确的句子时，不进入content函数，也就是不进行语义分析），然后根据句子的类型进行分类，进入不同的语义处理部分。 对于赋值语句，关键是产生正确的处理算术表达式E的四元式。 程序中的ec函数的功能就是产生算术表达式的四元式，在ec函数中使用了两个栈idshed，opshed，分别是算术表达式的数据栈和符号栈。每次提取一个数字和一个算符，然后将算符与与栈顶算符进行优先级比较，优先级高则将单前数字和算符进栈，低或者相等的话则将当前栈顶元素进行合并，产生四元式。直至整个算术表达式结束。其中还有一些细节问题，具体的做法可以参看程序。 对于实验给定的if语句的文法格式，条件判断式C只中可能是>或者<=两种关系，不可能是布尔表达式，这样程序就简单的多了。 通过ec函数可以产生条件判断式C中的E的四元式，然后只要加上转向四元式就可以了。本实验程序中只给出真出口的转向四元式，没有给出假出口的转向四元式，这在实际中是不可以的，但在
本实验中，实际上是对每条独立的语句进行语法分析，给出假出口转向四元式实际上意义不大，而且假出口转向语句的转移目标必须要到整个语句分析结束以后才可以知道，这样就要建立栈，然后回填，这样会使程序复杂很多，所以没有加上假出口转向四元式。 对于while语句，具体的做法和if语句差不多，所不同的是当while语句结束时，要多出一条无条件转向四元式，重新转到条件判断式C的第一条四元式。当要产生无条件转向四元式时，它的转向目标C的第一条四元式已经产生了，所以具体的做起来是不太困难的。只要记下当前while中的C的第一条四元式的位置，填上就可以了。 整个程序的结束是当读入“. ”时，程序就中止。 程序中还有很多细节问题，具体的可以后面的附录：程序的完整代码。 三、测试程序 ff:=6+6*6-; if sl>89+56*67 then f:=7*7+4; ff:=6+6*6-6%4+8; if sl+78*76>89*56+67 then while a-7>98+45*45 do f:=7*7+4; . 四、运行结果 首先对测试程序进行语法分析，识别出正确的句子，当识别出正确的句子时，就对当前句子进行语义分析，而语法不正确的句子不进行语义分析。 ff:=6+6*6- Error(4):Except ID or NUM ; Error(2):Syntax error if sl>89+56*67 then f:=7*7+4; success!!! (1) [ *, 56, 67, T1 ]
20个代码生成框架 11.1 CodeSmith http： 官方论坛： http： 版权形式：30天试用 开源：否需要先注册确认后才能下载 1.2 MyGenerator MyGenerator是又一个国外很不错的代码生成工具，有人觉得比CodeSmith 简单、好用。 所有api可以在帮助菜单中找到。 http： 官方论坛： 版权形式： 免费 开源：否 1.3 NHibernate. http： 官方论坛： 版权形式：
免费 开源：否 1.4湛蓝.Net代码生成器 http： 官方论坛： http： 版权形式： 免费 开源：否 1.5动软.NET代码自动生成器 一款人气很旺的免费C#代码生成器 http： 官方论坛： 版权形式： 免费 开源：否 1.6 CodePlus 专为sql server c#语言设计的代码生成器,功能还是很强大http： 官方论坛：
版权形式： 需要少量的注册费用 开源：否下载地址很神秘 1.7 CodeMaker http： 官方论坛： 版权形式： 免费 开源：否 https://www.doczj.com/doc/2010657338.html,代码生成器 可以使用本工具生成https://www.doczj.com/doc/2010657338.html,和C#语言的代码，以及三层架构与ORM架构代码，并且使用的ORM持久化组件是开源的，您可以在本软件的安装目录下找到它 官方论坛： 版权形式： 免费 开源：否 1.9 BMW业务模型及代码生成器 一款人气很旺的免费C#代码生成器
官方论坛： 版权形式： 免费 开源：否 1.10飞鹰CoolCoder 专门为采用nhibernate做关系对象影射架构的系统提供代码的工具，简单易用，虽然不提供源码，我们可以用反编译工具对其反编译看源码。这是个很不错的学习机会。 官方论坛： 版权形式： 免费 开源：否 1.11 AutoCoder自动代码生成器 AutoCoder自动代码生成器是一个根据模板自动生成代码的代码生成工具，根据模板的不同，可以生成任何语言（如： ASP、C#、C++BUILDER、DELPHI、JAV A、JSP、PHP、V B、https://www.doczj.com/doc/2010657338.html,……），不同层次结构（B/S、C/S、n-tiger……），基于不同数据库（ORACL E、MSSQL、MYSQL、
C++语言编写。。 #include
char *base; }stack_char; stack_num S_num;//定义 stack_char S_char;//定义 char fu[18] = {'\n', ')', '+', '-', '*', '/', '%', '^', 'Q', 'L', 'C', 'S', 'T', 'c', 's', 't', '('}; int compare[1000];//表现出各运算符号的优先级 double shu[1000];//存储"数"的数组 double dai_result;//运算的结果，是为了处理M运算(简介函数里有M的定义) int biao = 0;//和dia_result一样，为了处理M运算 char line[SIZE];//输入的所要计算的表达式 void init()//初始化 { compare[fu[0]] = -2;//用数字的大小表现出符号的优先级 compare[fu[1]] = -1; compare[fu[2]] = 2; compare[fu[3]] = 2; compare[fu[4]] = 4; compare[fu[5]] = 4; compare[fu[6]] = 4;
编译原理综合性实验报告-分析中间代码生成程序分析XXXXXX计算机系综合性实验 实验报告 课程名称编译原理实验学期 XXXX 至 XXXX 学年第 X 学期学生所在系部计算机系年级 X 专业班级 XXXXXX 学生姓名 XXX 学号 XXXXXXXXXXXX 任课教师XXX 实验成绩 计算机系制 《编译原理》课程综合性实验报告 开课实验室: 年月日实验题目分析中间代码生成程序 一、实验目的 分析PL/0编译程序的总体结构、代码生成的方法和过程;具体写出一条语句的中间代码生成过程。 二、设备与环境 PC兼容机、Windows操作系统、Turbo Pascal软件等。 三、实验内容 1. 分析PL/0程序的Block子程序，理清PL/0程序结构和语句格式。画出Block 子程序的流程图，写出至少两条PL/0程序语句的语法格式。 2. 分析PL/0程序的Block子程序和Gen子程序，了解代码生成的方法和过程。 使用概要算法来描述语句的代码生成过程。 3. 自己编写一个简单的PL/0程序，能够正确通过编译，得到中间代码。列出自
己编写的源程序和编译后得到的中间代码。 4. 从中选择一个语句或表达式，写出代码生成的过程。要求从自己的源程序中 选择一条语句，结合这条语句写出语义分析和代码生成过程。在描述这个过程中，要说清楚每个功能有哪个子程序的哪条语句来完成，说清楚语句和参数的含义和功能。 四、实验结果及分析 (一)Block子程序分析 1.常量声明的分析: 常量声明部分的语法结构定义为如下形式:
单片机简易计算器设计 Company Document number：WTUT-WT88Y-W8BBGB-BWYTT-19998
一、设计要求 1．设计4*4的键盘，其中10个数字键0~9，其余6个为“+”“-”“*”“/”“=”和“C” 2．设计2位LED接口电路 3．实现1位数的简单运算 二、硬件系统设计 1、LED接口电路 简易计算器需要2位8段码LED显示电路。用8031单片机经8255A扩展2位8段码LED显示器，用8255A的A口作为段码（字形代码）数据口，PB0和PB1作为位控制端口。在位控制口加集电极开路的反相高压驱动器74LS06以提供驱动LED显示器所需的足够大的电流，然后接至各数码显示器的共阴极端。同理，在段码数据口集电极开路的正相高压驱动器74LS07提供足够大的电流，然后接到数码显示器的各段。逻辑电路结构如下：
2、键盘接口电路 简易计算器需要4*4的行列式键盘。用8031单片机经8255A扩展4*4行列式键盘，8255A的B口和C口用于扩展键盘接口，B口高4位作为输出口，C口低4位作为输入口。逻辑电路结构如下： 3、计算器逻辑电路图 将LED接口电路和键盘接口电路结合到一起就是简易计算器的逻辑电路图，如下： 三、软件设计 1、LED显示程序设计 LED显示器由七段发光二极管组成，排列成8字形状，因此也成为七段LED显示器，器排列形状如下图所示：
为了显示数字或符号，要为LED显示器提供代码，即字形代码。七段发光二极管，再加上一个小数点位，共计8段，因此提供的字形代码的长度正好是一个字节。简易计算器用到的数字0~9的共阴极字形代码如下表： 0~9七段数码管共阴级字形代码 2位LED显示的程序框图如下： 2、读键输入程序设计 为了实现键盘的数据输入功能和命令处理功能，每个键都有其处理子程序，为此每个键都对应一个码——键码。为了得到被按键的键码，现使用行扫描法识别按键。其程序框图如下： 3、主程序设计 （1）数值送显示缓冲程序设计 简易计算器所显示的数值最大位两位。要显示数值，先判断数值正负，如果是负值，则符号位显示“-”，然后将数值除以10，余数送显最最低位，判断商是否为0，若为0则返回，若不为0，则将商除以10，将余数送显高位。程序框图如下： （2）运算主程序设计
语义分析及中间代码生成程序设计原理与实现技术 XXX 1028XXX2 计科1XXX班 1.程序功能描述 完成以下描述赋值语句和算术表达式文法的语法制导生成中间代码四元式的过 程。 G[A]:A→V:=E E→E+T∣E-T∣ T→T*F∣T/F∣F F→(E)∣i V→i 说明：终结符号i 为用户定义的简单变量,即标识符的定义。 2. 设计要求 （1）给出每一产生式对应的语义动作；（2）设计中间代码四元式的结构（暂不与符号表有关）。（3）输入串应是词法分析的输出二元式序列，即某算术表达式“实验项目一”的输出结果。输出为输入串的四元式序列中间文件。（4）设计两个测试用例（尽可能完备），并给出程序执行结果四元式序列。 3.主要数据结构描述： 本程序采用的是算符优先文法，文法以及算符优先矩阵是根据第四次实验来修改的，所以主要的数据结构也跟第四次差不多，主要为文法的表示，FirstVT集和LastVT 集以及算符优先矩阵：
算符优先矩阵采用二维字符数组表示的： char mtr[9][9]; //算符优先矩阵 4.程序结构描述： 本程序一共有8功能函数： void get(); //获取文法 void print(); //打印文法 void fun(); //求FirstVT 和LastVT void matrix(); //求算符优先矩阵 void test(); //测试文法 int cmp(char a,char b); 比较两个运算符的优先级 1 0 -1 void out(char now,int avg1,int avg2); //打印四元式 int ope(char op,int a,int b); //定义四元式计算方法 5.实验代码 详见附件 6.程序测试 6.1 功能测试 程序运行显示如下功能菜单：
import javax.swing.*; import java.awt.event.*; import java.awt.*; import https://www.doczj.com/doc/2010657338.html,ng.Math; class ring extends JFrame implements ActionListener { //定义成员变量： //JFrame frame;//定义一个窗口类； JTextField text;//定义一个文本框类； JLabel label;//定义一个标签类； JPanel p1,p2,p3,p4,p5,p6;//定义面板类； String s1,s,s2;//定义三个字符串变量； int count=0; JButton a1,a2,a3,a4,a5,a6,b1,b2,b3,b4,b5,b6,c1,c2,c3,c4,c5,c6,d1,d2,d3,d4 ,d5,d6; //ring的构造函数； ring() { this.setTitle("计算器"); // super("计算器"); JMenuBar menubar1=new JMenuBar();//新建菜单条； this.setJMenuBar(menubar1); JMenu menu1=new JMenu("编辑(E)"); JMenu menu2=new JMenu("查看(V)"); JMenu menu3=new JMenu("帮助(H)"); menubar1.add(menu1); menubar1.add(menu2); menubar1.add(menu3); JMenuItem item1=new JMenuItem("复制(c) ctrl+c"); JMenuItem item2=new JMenuItem("粘贴(p) ctrl+v"); JMenuItem item3=new JMenuItem("标准型(T)"); JMenuItem item4=new JMenuItem("科学型(s)"); JMenuItem item5=new JMenuItem("数字分组(I)"); JMenuItem item6=new JMenuItem("帮助主题(H)"); JMenuItem item7=new JMenuItem("关于计算机(A)"); menu1.add(item1); menu1.add(item2); menu2.add(item3); menu2.add(item4); menu2.add(item5); menu3.add(item6);
编译方法实验报告 2011年10月
一、实验目的 熟悉算术表达式的语法分析与中间代码生成原理。 二、实验内容 （1）设计语法制导翻译生成表达式的四元式的算法； （2）编写代码并上机调试运行通过。 输入——算术表达式； 输出——语法分析结果； 相应的四元式序列。 （3）设计LL(1)分析法或LR(0)分析法的属性翻译文法，并根据这些属性翻译文法，使用扩展的语法分析器实现语法制导翻译。 三、实验原理及基本步骤 ●算术表达式文法： G(E)： E →E ω0 T | T T →T ω1 F | F F → i | (E) ●文法变换： G’(E) E →T {ω0 T} T →F {ω1 F} F → i | (E) ●属性翻译文法： E →T {ω0“push(SYN,w)” T “QUAT”} T →F {ω1“push(SYN, w)” F “QUAT”} F →i “push(SEM, entry(w))” | (E) 其中： push(SYN, w) —当前单词w入算符栈SYN; push(SEM, entry(w)) —当前w在符号表中的入口值压入语义栈SEM; QUA T —生成四元式函数 i．T = newtemp; ii．QT[j] =( SYN[k], SEM[s-1], SEM[s], T); j++; iii．pop( SYN, _ ); pop( SEM, _ ); pop( SEM, _ ); push( SEM, T ); ●递归下降子程序： 数据结构：SYN —算符栈； SEM —语义栈；
四、数据结构设计 使用递归的结构进行四元式的设计，同时，运用堆栈结构将四元式的输出序列打印出来 while ( exp[i]=='+' || exp[i]=='-'){ syn[++i_syn]=exp[i]; //push(SYN,w) i++; //read(w) T(); quat();} while ( exp[i]=='*' || exp[i]=='/'){ syn[++i_syn]=exp[i]; //push(SYN,w) i++; //read(w) F(); quat();} void quat(){ strcpy(qt[j],"(, , , )");
超详细 一、因为计算器设计的控件太多，不便使用控制台应用程序完成，所以这里 使用Windows窗体应用程序，并命名为Calc,如下图所示： 二、向窗体中拖入需要的控件，如下图所示： （完成效果图） 结果显示区（作者博客左边的文本框）是TextBox控件，并修改其name为txtShow，按键0~9为Button控件，并将其name分别修改为btn_0、btn_1、btn_2、btn_3、btn_4、btn_5、btn_6、btn_7、btn_8、btn_9；按键【负数】的name值修改为btn_sign，按键【.】的name修改为btn_dot，按键【+-*/】的name值分别修改为btn_add、btn_sub、btn_mul、btn_div，按键【=】的name值修改为btn_equ，按键【倒数】的name值修改为btn_rev，按键【平方】的name值修改为btn_sqr，按键【开方】的name值修改为btn_sqrt。右边的计算器图片空间是PictureBox，作者博客控件是LinkLabel，可以不添加，以上所有控件均可按照需求添加，只保留自己需要的按钮控件和textbox控件即可。 三、代码部分（含解释），采用switch多分支语句编写 using System; using System.Drawing; using System.Collections; using https://www.doczj.com/doc/2010657338.html,ponentModel; using using System.Data; namespace Calc { ///
实验四中间代码生成 一．实验目的： 掌握中间代码的四种形式（逆波兰式、语法树、三元式、四元式）。 二．实验内容： 1、逆波兰式定义:将运算对象写在前面，而把运算符号写在后面。用这种表示法表示的表 达式也称做后缀式。 2、抽象（语法）树：运算对象作为叶子结点，运算符作为内部结点。 3、三元式：形式序号：（op,arg1,arg2） 4、四元式：形式（op,arg1,arg2,result） 三、以逆波兰式为例的实验设计思想及算法 (1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。 (2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。 (3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。 (4)如果不是数字，该字符则是运算符，此时需比较优先关系。 做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。倘若不是的话，则将此运算符栈顶的运算符从栈中弹出，将该字符入栈。 (5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。 四、程序代码： //这是一个由中缀式生成后缀式的程序 #include<> #include<> #include<> #include<> #define maxbuffer 64 void main() { char display_out(char out_ch[maxbuffer], char ch[32]); //int caculate_array(char out_ch[32]); static int i=0; static int j=0; char ch[maxbuffer],s[maxbuffer],out[maxbuffer]; cout<<"请输入中缀表达式: ";
代码生成器使用规则 1.创建一个表，红色为必须字段，该sql执行前去掉行前的tab符号 DROP TABLE IF EXISTS `books`; CREATE TABLE `books` ( `id` varchar(64) NOT NULL COMMENT '编号', `bookid` varchar(30) default NULL COMMENT '书号', `name` varchar(100) default NULL COMMENT '书名', `author` varchar(100) default NULL COMMENT '作者', `price` float default NULL COMMENT '单价', `number` int(11) default NULL COMMENT '存库', `publish` varchar(30) default NULL COMMENT '出版社', `img` varchar(30) default 'upload/default.jpg' COMMENT '封面', `create_by` varchar(64) default NULL COMMENT '创建者', `create_date` datetime default NULL COMMENT '创建时间', `update_by` varchar(64) default NULL COMMENT '更新者', `update_date` datetime default NULL COMMENT '更新时间', `remarks` varchar(255) default NULL COMMENT '备注信息', `del_flag` char(1) NOT NULL COMMENT '删除标志', PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 2.修改Generate类，修改如下 String moduleName = "books"; // 模块名，例：sys String subModuleName = ""; // 子模块名（可选） String className = "books"; // 类名，例：user String classAuthor = "石义良"; // 类作者，例：ThinkGem String functionName = "图书"; // 功能名，例：用户 // 是否启用生成工具 Boolean isEnable = true; 右击，run as java application 3.刷新整个项目，将com.thinkgem.jeesite.modules.books.web.BooksController中的 return"books/booksList"; return"books/booksForm"; 修改为 return"modules/books/booksList"; return"modules/books/booksForm"; 4.将/JeeSite/src/main/java/com/thinkgem/jeesite/modules/books/entity/Books.java中的父类修改IdEntity，并删除id成员，添加其他非红色字段成员及get、set方法。并将表映射为books表。 5.以thinkgem身份登录，在菜单管理中添加菜单：
怎么提高工作效率怎么提高学习效率如何进行时间管理怎么自我充电，不断提高自己这都是我们所关心的问题。而除了学习快速阅读方法，学习记忆方法外，还有什么可以提高我们的效率呢下面为大家介绍提高工作效率的十个方法。 1．确定方向不走冤枉路 俗话说：“马壮车好不如方向对”，这句话的典故来自春秋战国时期，有位夫子准备了很多行李，准备去南方的楚国，就向路人问路。路人说：“此路非很楚国”这位夫子说：“我的马很壮，没有关系。”路人又再强调这不是去楚国的方向，夫子还是固执地说：“我的车很坚固”。路人只好叹息：“这不是去楚国的方向呀！”方向错了，再怎么努力也是枉然的。 仔细想想做这项工作的重点是什么，目标是什么，希望通过这项工作得到什么成果。按目前的方向是不是真的能得到想要的结果，与你的主管和上下流流程的同事一起讨论，再决定整个方向和流程。 提醒：光忙是不够的。关键是：我们到底在忙什么。 2．做行事历和项目执行计划 事先做好计划表可以帮助你理清想做完的事。你可以利用以下的工具： *电脑软件，比如计划表、日程表和日历
*日历或是商务日志 *自己设计的简单表格 以一天的计划表来说，首先列出你必须做的事。这些是你今天的首要工作；然后列出应该做的事，以及可做但不急的事。然后评估各项工作所需的时间，最后决定如何把时间分配到这些工作上。记住，应该把最重要的事情放在一天中状态最好的时间去做。一天的时间规划完成后，可以延伸成一周的计划，决定一周内最重要及必须做的事。每天确认行程是否按计划推进。 提醒：知道计划何时开始，就开始列进度，但不要让计划的时间取代了执行的时间。 3．运用系统思考，工作分类进行。 养成把握重点，循序渐进，集中力量的习惯，决定次序，从最重要的事情着手。我们必须先决定哪一个工作比较重要，优先去做；哪些不重要，可以缓办。不考虑优先顺序所产生的另一个结果会是一事无所。而且被拖延或耽误的事情，等以后再提出来的时候已经为时过晚了。 ●按工作的重要性决定完成工作的优先顺序 ●按工作的重要性决定投入工作的时间 ●同性质、同种类、类似性高的工作一次解决 ●不断思考是否有更有效率的工作方法
20个代码生成框架 1 1.1 CodeSmith 一款人气很旺国外的基于模板的dotnet代码生成器 官方网站：http：//https://www.doczj.com/doc/2010657338.html, 官方论坛：http：//https://www.doczj.com/doc/2010657338.html,/default.aspx 版权形式：30天试用 开源：否 需要先注册确认后才能下载 1.2 MyGenerator MyGenerator是又一个国外很不错的代码生成工具，有人觉得比CodeSmith简单、好用。 所有api可以在帮助菜单中找到。 官方网站：http：//https://www.doczj.com/doc/2010657338.html,/portal/default.aspx 官方论坛： 版权形式：免费 开源：否 1.3 NHibernate. NHibernate是Hibernate公司在Java自动生成领域取得巨大成功后推出的一款ORM工具. 官方网站：http：//https://www.doczj.com/doc/2010657338.html,/ 官方论坛： 版权形式：免费 开源：否 1.4 湛蓝.Net代码生成器
一款基于软件自动生成理念，能直接生成应用的dotnet代码生成器 官方网站：http：//https://www.doczj.com/doc/2010657338.html, 官方论坛：http：//https://www.doczj.com/doc/2010657338.html,/ 版权形式：免费 开源：否 1.5 动软.NET代码自动生成器 一款人气很旺的免费C#代码生成器 官方网站：http：//https://www.doczj.com/doc/2010657338.html, 官方论坛： 版权形式：免费 开源：否 1.6 CodePlus 专为sql server c#语言设计的代码生成器,功能还是很强大 官方网站：http：//https://www.doczj.com/doc/2010657338.html, 官方论坛： 版权形式：需要少量的注册费用 开源：否 下载地址很神秘 1.7 CodeMaker asp,jsp,php代码生成工具，自动生成维护数据库信息的动态网页的代码生成器。它可以帮助ASP、JSP、PHP开发人员快速的开发简单的数据库维护程序。无需任何编码，只需将数据库结构导入到CodeMaker中并做简单的设置，CodeMaker即可生成完整的数据库操作页面。用CodeMaker可以简单快速的创建网站后台维护程序。提高开发效率数十倍以
j a v a简单计算器源代码集团企业公司编码：（LL3698-KKI1269-TM2483-LUI12689-ITT289-
简单计算器代码packagecalcultorthree; /** *本例实现了简单计算器代码，具备加减乘除和正弦功能，旨在抱砖引玉。熟悉java的同学，可以在此基础上实现更复杂的功能。 *@authorFjsh */ publicclassCalcultorThree{ //新建对象，在构造函数中进行初始化 JFrameframe;//新建窗体对象 JButtonbuttonzero,buttondot,buttonequal;//新建按钮“0”“.”“=”JButtonbuttonplus,buttonminus,buttonmultiple,buttondevision, buttonsin,buttontozero;//新建按钮“+”“-”“*”“/”“sin”和归零按钮JButtonbuttonone,buttontwo,buttonthree,buttonfour,buttonfive,buttonsix, buttonseven,buttoneight,buttonnine;//新建数字按钮 “0”“1”“2”“3”“4”“5”“6”“7”“8”“9” JPanelpanelwest,panelcenter,paneleast;//新建三个面板 TextFieldtf;//新建文本区域对象 publicCalcultorThree(){ //初始化对象 tf=newTextField(30);//构造空文本字段，字符宽度为30 frame=newJFrame("CalculatorThree");//构造窗体对象，名称为“CalculatorThree”
C语言高效编程的几招小技巧 这篇文章主要介绍了C语言高效编程的几招小技巧,本文讲解了以空间换时间、用数学方法解决问题以及使用位操作等编辑技巧,并给出若干方法和代码实例,需要的朋友可以参考下 引言： 编写高效简洁的C语言代码，是许多软件工程师追求的目标。本文就工作中的一些体会和经验做相关的阐述，不对的地方请各位指教。 第1招：以空间换时间 计算机程序中最大的矛盾是空间和时间的矛盾，那么，从这个角度出发逆向思维来考虑程序的效率问题，我们就有了解决问题的第1招——以空间换时间。 例如：字符串的赋值。 (使用的时候可以直接用指针来操作。) 从上面的例子可以看出，A和B的效率是不能比的。在同样的存储空间下，B直接使用指针就可以操作了，而A需要调用两个字符函数才能完成。B的缺点在于灵活性没有A好。在需要频繁更改一个字符串内容的时候，A具有更好的灵活性；如果采用方法B，则需要预存许多字符串，虽然占用了大量的内存，但是获得了程序执行的高效率。 如果系统的实时性要求很高，内存还有一些，那我推荐你使用该招数。 该招数的变招——使用宏函数而不是函数。举例如下： 方法C：
SET_BITS(MCDR2, MCDR2_ADDRESS, RegisterNumber); SET_BITS(MCDR2, MCDR2_ADDRESS, RegisterNumber); 函数和宏函数的区别就在于，宏函数占用了大量的空间，而函数占用了时间。大家要知道的是，函数调用是要使用系统的栈来保存数据的，如果编译器里有栈检查选项，一般在函数的头会嵌入一些汇编语句对当前栈进行检查；同时，CPU也要在函数调用时保存和恢复当前的现场，进行压栈和弹栈操作，所以，函数调用需要一些CPU时间。而宏函数不存在这个问题。宏函数仅仅作为预先写好的代码嵌入到当前程序，不会产生函数调用，所以仅仅是占用了空间，在频繁调用同一个宏函数的时候，该现象尤其突出。 D方法是我看到的最好的置位操作函数，是ARM公司源码的一部分，在短短的三行内实现了很多功能，几乎涵盖了所有的位操作功能。C方法是其变体，其中滋味还需大家仔细体会。 第2招：数学方法解决问题 现在我们演绎高效C语言编写的第二招——采用数学方法来解决问题。
#include
编写高效简洁的C语言代码，是许多软件工程师追求的目标。本文就工作中的一些体会和经验做相关的阐述，不对的地方请各位指教。 第 1 招：以空间换时间 计算机程序中最大的矛盾是空间和时间的矛盾，那么从这个角度出发逆向思维来考虑程序的效率问题，我们就有了解决问题的第1招--以空间换时间。 例如：字符串的赋值。 从上面的例子可以看出，A和 B的效率是不能比的。在同样的存储空间下，B直接使用指针就可以操作了，而 A 需要调用两个字符函数才能完成。B的缺点在于灵活性没有 A好。在需要频繁更改一个字符串内容的时候，A 具有更好的灵活性；如果采用方法 B，则需要预存许多字符串，虽然占用了 大量的内存，但是获得了程序执行的高效率。 如果系统的实时性要求很高，内存还有一些，那我推荐你使用该招数。该招数的边招--使用宏函数而不是函数。举例如下：
函数和宏函数的区别就在于，宏函数占用了大量的空间，而函数占用了时间。大家要知道的是，函数调用是要使用系统的栈来保存数据的，如果编译器里有栈检查选项，一般在函数的头会嵌入一些汇编语句对当前栈进行检查；同时，CPU 也要在函数调用时保存和恢复当前的现场，进行压栈和弹栈操作，所以，函数调用需要一些CPU时间。而宏函数不存在这个问题。宏函数仅仅作为预先写好的代码嵌入到当前程序，不会产生函数调用，所以仅仅是占用了空间，在频繁调用同一个宏函数的时候，该现象尤其突出。函数和宏函数的区别就在于，宏函数占用了大量的空间，而函数占用了时间。大家要知道的是，函数调用是要使用系统的栈来保存数据的，如果编译器里有栈检查选项，一般在函数的头会嵌入一些汇编语句对当前栈进行检查；同时，CPU也要在函数调用时保存和恢复当前的现场，进行压栈和弹栈操作，所以，函数调用需要一些CPU时间。而宏函数不存在这个问题。宏函数仅仅作为预先写好的代码嵌入到当前程序，不会产生函数调用，所以仅仅是占用了空间，在频繁调用同一个宏函数的时候，该现象尤其突出。 D方法是我看到的最好的置位操作函数，是 ARM 公司源码的一部分，在短短的三行内实现了很多功能，几乎涵盖了所有的位操作功能。C方法是其变体，其中滋味还需大家仔细体会。 第 2 招：数学方法解决问题
实验 6 简单中间代码生成 1、实验目的： 综合运用所学知识，集成词法分析、符号表管理等程序的成果，在语法分析和文法属性计算的基础上，完成中间代码的生成工作。让学生全面了解一个编译器工作的全过程，真正全面掌握编译的思想和方法。 2、实验的基本原理 对于一个给定文法，通过改写文法，使其满足LR（1）文法的要求，根据语义确定文法符号的属性，确定语义规则或翻译方案；根据文法特点构造LR(1)分析表，进而构造语法分析和属性计算程序。分析程序在分析表的驱动下，完成对给定的句子进行语法分析和属性计算工作，最后生成三地址中间代码序列。 3、实验内容及要求 a.实验所用文法如下。 statmt → id = exp exp → exp addop term | term addop →+ | - term→ term mulop factor | factor mulop → * | / factor → ( exp ) | id | num 其中id和num为实验二中定义的标识符和常数，因此这里还需要一个小的词法分析器来得到id和num。 b.构造文法LR（1）项目集，构造ACTION和GOTO矩阵，确认文法满足LR（1） 文法要求。 c.按一般高级语言赋值语句的计算要求定义文法的属性和语义规则，属性计算的结果 是将给定赋值语句翻译成三地址代码序列，并输出此序列。 d.从数据文件中读出赋值语句，并对其进行语法分析，对合法语句，输出其翻译结果。 e.实验数据文件中应该有多个语句，可能有正确的也应该有错误的语句；语句中的表 达式有形式简单的也应该有复杂的。每个表达式写在一行，以$结束。 4、实验步骤 准备好用于实验的赋值语句序列，并存储在文件中。 a.编写单词分析子程序，能从源程序中分离出单词（包括标识符和常数）；词法分析 器以子程序形式出现，当需要进行词法分析时进行调用；