一、word页眉页脚概述

      页眉页脚是word文档中每个页面里上、下页边距界定的用于存储和显示文本、图形的信息区。页眉页脚常用于word文档的打印修饰，内容可以包括文档当前页页码、文档页数、文档建立日期时间、文档作者、文档标题、文档路径和文件名、公司徽标、边框线、特制图形等文字或图形。在word文档中设置页眉页脚可以在文档的任何显示浏览视图下进行，但只有页面视图、文档打印预览和文档打印中可以显示页眉页脚，其它视图下均看不见页眉页脚；将设置了页眉页脚的word文档另保存为Web网页文件时，其页眉页脚将不仅不显示而且也不能打印输出，不过当把Web网页文件转换回word文档后又可以还原其页眉页脚;在word文档中设置页眉页脚可自始至终用同一个页眉页脚，也可在文档的不同部分用不同的页眉页脚。例如，可以在首页上使用与众不同的页眉页脚或者首页上不使用页眉和页脚，还可以在奇数页和偶数页上设置不同的页眉页脚，当然也可以在文档的不同部分设置使用不同的页眉页脚，但必须进行文档分节处理。word应用程序中的“页眉页脚”命令位于“视图”菜单中，执行“页眉页脚”命令进入页眉页脚编辑状态系统会自动显示“页眉页脚”工具栏。

二、奇偶页显示不同内容
      在专业出版的书籍中，常常看到书籍中奇偶页的页眉会显示不同的内容，以方便用户在书籍中快速查找资料。而在Word 2000中，用户也可以很方便地在文档奇偶页的页眉中显示不同的内容。
      打开需要设置页眉格式的Word文档，选择“文件”菜单中“页面设置”命令，打开“页面设置”对话框，接着单击“版式”选项卡，在“页眉和眉脚”选项区中将“奇偶页不同”复选框选中，最后单击“确定”按钮结束设置。
      选择“视图”菜单中“页眉和页脚”命令，将视图切换到页眉和页脚视图方式。这时可以看到光标在奇数页页眉编辑区中闪烁，输入奇数页眉内容；单击“页眉和页脚”工具栏上的“显示下一项”按钮，将光标移到偶数页页眉编辑区，输入偶数页页眉内容。

三、在页眉中显示章编号及章标题内容
      要想在Word文档中实现在页眉中显示该页所在章的章编号及章标题内容的功能，用户首先必须在文档中对章标题使用统一的章标题样式，并且对章标题使用多级符号进行自动编号，然后按照如下的方法进行操作。
      选择“视图”菜单中“页眉和页脚”命令，将视图切换到页眉和页脚视图方式。
      选择“插入”菜单中的“域”命令，打开“域”对话框。从“类别”列表框中选择“链接和引用”，然后从“域名”列表框中选择“StyleRef”域。
      单击“选项”命令，打开“域选项”对话框，单击“域专用开关”选项卡，从“开关”列表框中选择“\n”开关，单击“添加到域”按钮，将开关选项添加到域代码框中。
      单击“样式”选项卡，从“名称”列表框中找到章标题所使用的样式名称，如“标题1”样式名称，然后单击“添加到域”按钮。
      单击“确定”按钮将设置的域插入到页眉中，这时可以看到在页眉中自动出现了该页所在章的章编号及章标题内容。
四、修改页眉中的划线格式
      用户选择在文档中使用页眉后，在页眉中就会出现一条横贯页面的划线。如果你对系统设置的划线格式不满意的话，可以采用下面的方法进行修改。
      方法1：选择“视图”菜单中“页眉和页脚”命令，将视图切换到页眉和页脚视图方式。将光标定位到页眉位置处，选择“格式”菜单中的“边框和底纹”命令，打开“边框和底纹”对话框，单击“边框”选项卡，在“边框”设置页面中可以看到页眉中使用的是宽度为“0.75磅”的单实线。
      如果需要修改页眉中的划线格式，可在此对话框中对边框的线型、颜色、宽度等项目进行修改。例如将划线由单实线改为双实线时，首先在“线型”下拉列表中选择“双实线”，然后在预览区域中单击两次下线按钮，即可将线型更改成双实线。
      如果你不想在页眉中使用划线，只需在“设置”中选择“无”边框格式即可。
      方法2：在Word 2000中页眉中使用的划线格式是由“页眉”样式中的设置所决定的，如果你想永久改变在页眉中所使用划线的格式时，只要在“页眉”样式中对划线格式进行修改就可以了。
      选择“格式”菜单中的“样式”命令，打开“样式”对话框。在“样式”列表框中选择“页眉”，然后单击“更改”按钮，打开“更改样式”对话窗口。
      单击“格式”按钮，在弹出的菜单中选择“边框”选项，打开“边框和底纹”对话框，然后按照修改页眉中的划线格式方法1所介绍的操作方法修改页眉中的划线格式。修改结束后，单击“确定”按钮返回“更改样式”对话窗口。
      将“添至模板”复框选中，将样式添至附于活动文档的模板，以便使修改后的“页眉”样式可用于基于该模板新建的文档。单击“确定”按钮返回“样式”对话框，单击“应用”按钮结束设置。
      以后只要在文档中使用页眉，在页眉中就会自动应用经过修改后的划线格式。
五、在任意位置插入页码
      一般情况下我们都是在Word文档页面的上方或者下方位置插入页码。其实在Word 2000中，只要你愿意，就可以在Word文档页面中的任意位置插入页码。例如可以在页面左右页边中插入页码。
      选择“视图”菜单中“页眉和页脚”命令，将视图切换到页眉和页脚视图方式。单击“绘图”工具栏上的“文本框”按钮，然后拖动鼠标在文档中任意位置绘制一个文本框。
      单击“页眉和页脚”工具栏上的“插入页码”按钮。这时在文本框中就出现了该页所在的页码。此外还可以在文本框中添加其他说明文字，为文本框设置边框和底纹效果等。
      采用此方法设置的页码对该文档中所有的页面都有效。
六、 页眉页脚的使用技巧
     （1）、页眉页脚中横线格式的设置;①、横线格式设置;启动进入word页眉页脚编辑状态，默认情况下页眉文字、图形的下方都有一根水平实心细线（其属性为：边框、单实底线、0.75磅、边框间距1磅）。该线既可以删除取消也可以重新设置线条格式，它们都可以在页眉页脚编辑状态下通过调用“格式”菜单下的“边框和底纹”命令进入“边框和底纹”设置对话框，选择“边框”标签选项卡下的不同选项来完成;去掉页眉中的实心水平线的方法有;方法一、在“边框和底纹”对话框的“边框”标签选项卡下，选定“无边框”且设置应用范围为“段落”，单击“确定”按钮即可;方法二、在“边框和底纹”对话框的“边框”标签选项卡下，选定“方框”、“阴影”、“三维”或“自定义”之一，设置“颜色”为白色，选择作用范围为“段落”，单击“确定”。;方法三、在“页眉页脚”编辑状态下，选定页眉中包括段尾符在内的文字及图形，然后删除，关闭“页眉页脚”编辑返回word编辑状态即可;设置水平线格式的方法：在“边框和底纹”对话框的“边框”标签选项卡下，选定“自定义”——选择“线型”、 “颜色”和“宽度”——设置应用范围为“段落”，单击“确定;②、页眉线下文字的设置方法;页眉文字通常都位于实心水平线上方，称为线上文字。那么要实现线下文字该怎么办呢？其实很简单，只要在页眉的“边框和底纹”对话框中“边框”标签下将“自定义”边框的边框线设置成上边框类型并选择“作用范围”为“段落”，单击“确定”。页脚中一上、下线边框添加方法类似;
     （2）、任意位置上页眉页脚对象设置; word页眉页脚通常位于文档页面的上、下页边距处，但这不是一成不变的。事实上，我们可将各种页眉页脚对象通过添加文本框的方式放置到文档中的任意位置处，也可以采用绘制图形、绘制自选图形的方式添加页眉页脚对象。对文本框对象和图形对象又都可以设置阴影效果和三维效果。

七、页眉页脚的特殊应用
　　（1）、手动制作word稿纸;众所周知，在word中要采用稿纸方式，一般是必须安装“稿纸向导”并通过在执行“文件”菜单下的“新建”，选择新建对话框中的“其它文档”标签下的“稿纸向导”，一步一步往下设置直到完成，即可建立起统一格式的word稿纸方式文档。那么，未安装word应用程序的“稿纸向导”是不是就不能制作稿纸方式文档了呢？回答当然是否定的。事实上word的稿纸向导，不外乎是一系列word命令的集合而已。通过仔细揣摩，我们发现了word的稿纸方式的方框格子，类似于word的页眉页脚的功能——设置一次以后新建页中自动添加且在当前文档编辑状态下无法选定……。沿此思路，我们找到了手动调word命令制作稿纸方式文档的方法——进入“页眉页脚”编辑状态，用绘图工具画出稿纸方式的方框格子，并作“页面设置”下的“文档网格”设置。具体方法如下;新建一个空白文档，执行“视图”菜单下的“页眉页脚”命令，进入页眉页脚编辑状态，启用显示文档文字（单击页眉页脚工具栏上的“显示/隐藏文档文字”按钮），用绘图工具栏上的“矩形”按钮绘制一个存放一个汉字大小的方框格子于文档区最左边（方框连长均为0.75cm），选定方格并按下Ctrl键向右拖曳复制方格使其相邻边框线完全重叠，依此复制成每行20个方格（也可复制到5个方格时，按下Shift同时选定5个方格，松开Shift键，再按下Ctrl向右拖曳，同样使得相邻方格边框重叠复制）；同时选定第一行上的20个方框后将组合成一个整体，再按下Ctrl键向下复制成间隔等距的20行，又同时选定这20行方格再组合，最后画出一个大外框并设置线型为稍粗一点的线；至此，稿纸样式制作完成，但还需要设置页面中的“文档网格”格式为：每行20个字，每页20行。它是通过“文件”菜单下的“页面设置”来完成的;要制作个性化的word稿纸，也可用以上方法实现。如：设置稿纸方格线型、宽度、颜色，不同的行字符数和页行数等等。若想将已编辑存盘的word文档转为稿纸方式文档，可以在打开文档的条件下直接手动制作word稿纸来完成;
     （2）、制作丰富多彩的word水印水印本质上是页眉页脚中的特殊对象——艺术字对象。只是用word应用程序窗口“格式”菜单的“背景”——“水印”制作的水印可以通过水印对话框修改、修饰和删除水印，而在页眉页脚编辑状态下插入的艺术字、文本框和图形图片水印是跟“水印”对话框不相关联的。诚然，用“水印”命令制作的水印，也可在页眉页脚编辑状态下选定、复制、编辑修改和删除;①、制作铺满页面的水印;用word“格式”菜单下的“水印”命令制作的水印，只有一个；即使你重复使用多次“水印”命令，它也只能不断地覆盖生成水印，最终只保留最后一次制作的水印。要想实现“水印”铺满页面，可以通过进入“页眉页脚”编辑状态，选定“水印”然后进行拖曳复制或复制——粘贴——移动来完成。只要是由“水印”命令制作的水印，不管你复制生成了多少个它们都与“水印”命令对话框关联，所以可以使用它修改和删除水印。不过一次只能操作一个水印对象;②、制作文字水印;在页眉页脚编辑状态下，插入文本框到word文档的文本区域内，输入文本——设置字符格式——隐藏文本框的边框;③、添加图形图片水印;在页眉页脚编辑状态下，插入文本框，置插入点I型指针于文本框内，插入图形或图片。绘制图形可以设置阴影或三维效果

1 从const int i 说起
     有了const修饰的ic 我们不称它为变量，而称符号常量，代表着20这个数。这就是const 的作用。ic是不能在它处重新赋新值了。
     认识了const 作用之后，另外，我们还要知道格式的写法。有两种：const int ic=20;与int const ic=20;。它们是完全相同的。这一点我们是要清楚。总之，你务必要记住const 与int哪个写前都不影响语义。有了这个概念后，我们来看这两个家伙：const int * pi与int const * pi ，按你的逻辑看，它们的语义有不同吗？呵呵，你只要记住一点，int 与const 哪个放前哪个放后都是一样的，就好比const int ic;与int const ic;一样。也就是说，它们是相同的。
     好了，我们现在已经搞定一个“双包胎”的问题。那么int * const pi与前两个式子又有什么不同呢？我下面就来具体分析它们的格式与语义吧！

2 const int * pi的语义
     我先来说说const int * pi是什么作用。看下面的例子：
int i1=30;
int i2=40;
const int * pi=&i1;
pi=&i2;     //4.注意这里，pi可以在任意时候重新赋值一个新内存地址
i2=80;     //5.想想看：这里能用*pi=80;来代替吗？当然不能
printf( “%d”, *pi ) ;   //6.输出是80

语义分析：
     看出来了没有啊，pi的值是可以被修改的。即它可以重新指向另一个地址的，但是，不能通过*pi来修改i2的值。这个规则符合我们前面所讲的逻辑吗？当然符合了！
     首先const   修饰的是整个*pi（注意，我写的是*pi而不是pi）。所以*pi是常量，是不能被赋值的（虽然pi所指的i2是变量，不是常量）。
     其次，pi前并没有用const 修饰，所以pi是指针变量，能被赋值重新指向另一内存地址的。你可能会疑问：那我又如何用const 来修饰pi呢？其实，你注意到int * const pi中const 的位置就大概可以明白了。请记住，通过格式看语义。

3 再看int * const pi
     确实，int * const pi与前面的int const * pi会很容易给混淆的。注意：前面一句的const 是写在pi前和*号后的，而不是写在*pi前的。很显然，它是修饰限定pi的。我先让你看例子：
int i1=30;
int i2=40;
int * const pi=&i1;
//pi=&i2;     4.注意这里，pi不能再这样重新赋值了，即不能再指向另一个新地址。
       //所以我已经注释了它。
i1=80;     //5.想想看：这里能用*pi=80;来代替吗？可以，这里可以通过*pi修改i1的值。
     //请自行与前面一个例子比较。
printf( “%d”, *pi ) ;   //6.输出是80

语义分析：
     看了这段代码，你明白了什么？有没有发现pi值是不能重新赋值修改了。它只能永远指向初始化时的内存地址了。相反，这次你可以通过*pi来修改i1的值了。与前一个例子对照一下吧！看以下的两点分析
     1). pi因为有了const 的修饰，所以只是一个指针常量：也就是说pi值是不可修改的（即pi不可以重新指向i2这个变量了）(看第4行)。
     2). 整个*pi的前面没有const 的修饰。也就是说，*pi是变量而不是常量，所以我们可以通过*pi来修改它所指内存i1的值（看5行的注释）
     总之一句话，这次的pi是一个指向int变量类型数据的指针常量。

我最后总结两句：
     1).如果const 修饰在*pi前则不能改的是*pi而不是指pi。
     2).如果const 是直接写在pi前则pi不能改。

3.补充三种情况。
     这里，我再补充以下三种情况。其实只要上面的语义搞清楚了，这三种情况也就已经被包含了。不过作为三种具体的形式，我还是简单提一下吧！

情况一：int * pi指针指向const int i常量的情况
const int i1=40;
int *pi;
pi=&i1;//这样可以吗？不行，VC下是编译错。
     //const int 类型的i1的地址是不能赋值给指向int 类型地址的指针pi的。否则pi岂不是能修改i1的值了吗！
pi=(int* ) &i1;　　//　这样可以吗？强制类型转换可是C所支持的。
       //VC下编译通过，但是仍不能通过*pi=80来修改i1的值。去试试吧！看看具体的怎样。

情况二：const int * pi指针指向const int i1的情况
const int i1=40;
const int * pi;
pi=&i1;//两个类型相同，可以这样赋值。很显然，i1的值无论是通过pi还是i1都不能修改的。

情况三：用const int * const pi申明的指针
int i
const int * const pi=&i;//你能想象pi能够作什么操作吗？pi值不能改，也不能通过pi修改i的值。因为不管是*pi还是pi都是const的。

熵在信息论的定义如下：
         如果有一个系统S内存在多个事件S = {E₁,...,E_n}, 每个事件的概率分布 P = {p₁, ..., p_n}，则每个事件本身的信息为

（对数以2为底，单位是比特(bit)）

（对数以e为底，单位是纳特/nats）

如英语有26个字母，假如每个字母在文章中出现次数平均的话，每个字母的信息量为

而汉字常用的有2500个，假如每个汉字在文章中出现次数平均的话，每个汉字的信息量为

整个系统的平均信息量为

这个平均信息量就是信息熵。因为和热力学中描述热力学熵的玻耳兹曼公式形式一样，所以也称为“熵”。

如果两个系统具有同样大的信息量，如一篇用不同文字写的同一文章，由于是所有元素信息量的加和，那么中文文章应用的汉字就比英文文章使用的字母要少。所以汉字印刷的文章要比其他应用总体数量少的字母印刷的文章要短。即使一个汉字占用两个字母的空间，汉字印刷的文章也要比英文字母印刷的用纸少。实际上每个字母和每个汉字在文章中出现的次数并不平均，因此实际数值并不如同上述，但上述计算是一个总体概念。使用书写单元越多的文字，每个单元所包含的信息量越大。

1. 熵均大于等于零，即，。
2. 设N是系统S内的事件总数，则熵。当且仅当p1=p2=...=pn时，等号成立，此时系统S的熵最大。
3. 联合熵：，当且仅当X，Y在统计学上相互独立时等号成立。
4. 条件熵：，当且仅当X，Y在统计学上相互独立时等号成立。

1.4.1. Select（选择）

SQL 里面最常用的命令是 SELECT 语句，用于检索数据。语法是：

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
* | expression [ AS output_name ] [, ...]
[ INTO [ TEMPORARY | TEMP ] [ TABLE ] new_table ]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ { UNION | INTERSECT | EXCEPT [ ALL ] } select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
[ FOR UPDATE [ OF class_name [, ...] ] ]
[ LIMIT { count | ALL } [ { OFFSET | , } start ]]

现在我们将通过不同的例子演示 SELECT 语句复杂的语法。用于这些例子的表在 供应商和部件数据库 里定义。

SELECT * FROM PART
WHERE PRICE > 10;

 PNO |  PNAME  |  PRICE
-----+---------+--------
3  |  Bolt   |   15
4  |  Cam    |   25

SELECT PNAME, PRICE
FROM PART
WHERE PRICE > 10;

                      PNAME  |  PRICE
--------+--------
Bolt   |   15
Cam    |   25

SELECT PNAME, PRICE
FROM PART
WHERE PNAME = 'Bolt' AND
(PRICE = 0 OR PRICE <= 15);

 PNAME  |  PRICE
--------+--------
Bolt   |   15

SELECT PNAME, PRICE * 2 AS DOUBLE
FROM PART
WHERE PRICE * 2 < 50;

 PNAME  |  DOUBLE
--------+---------
Screw  |    20
Nut    |    16
Bolt   |    30

SELECT S.SNAME, P.PNAME
FROM SUPPLIER S, PART P, SELLS SE
WHERE S.SNO = SE.SNO AND
P.PNO = SE.PNO;

 SNAME | PNAME
-------+-------
Smith | Screw
Smith | Nut
Jones | Cam
Adams | Screw
Adams | Bolt
Blake | Nut
Blake | Bolt
Blake | Cam

select sname, pname from supplier
JOIN sells USING (sno)
JOIN part USING (pno);

 sname | pname
-------+-------
Smith | Screw
Adams | Screw
Smith | Nut
Blake | Nut
Adams | Bolt
Blake | Bolt
Jones | Cam
Blake | Cam
(8 rows)

SELECT AVG(PRICE) AS AVG_PRICE
FROM PART;

 AVG_PRICE
-----------
14.5

SELECT COUNT(PNO)
FROM PART;

 COUNT
-------
4

SELECT S.SNO, S.SNAME, COUNT(SE.PNO)
FROM SUPPLIER S, SELLS SE
WHERE S.SNO = SE.SNO
GROUP BY S.SNO, S.SNAME;

 SNO | SNAME | COUNT
-----+-------+-------
1  | Smith |   2
2  | Jones |   1
3  | Adams |   2
4  | Blake |   3

 S.SNO | S.SNAME | SE.PNO
-------+---------+--------
1   |  Smith  |   1
1   |  Smith  |   2
2   |  Jones  |   4
3   |  Adams  |   1
3   |  Adams  |   3
4   |  Blake  |   2
4   |  Blake  |   3
4   |  Blake  |   4

 S.SNO | S.SNAME | SE.PNO
-------+---------+--------
1   |  Smith  |   1
|   2
--------------------------
2   |  Jones  |   4
--------------------------
3   |  Adams  |   1
|   3
--------------------------
4   |  Blake  |   2
|   3
|   4

SELECT S.SNO, S.SNAME, COUNT(SE.PNO)
FROM SUPPLIER S, SELLS SE
WHERE S.SNO = SE.SNO
GROUP BY S.SNO, S.SNAME
HAVING COUNT(SE.PNO) > 1;

 SNO | SNAME | COUNT
-----+-------+-------
1  | Smith |   2
3  | Adams |   2
4  | Blake |   3

SELECT *
FROM PART
WHERE PRICE > (SELECT PRICE FROM PART
WHERE PNAME='Screw');

 PNO |  PNAME  |  PRICE
-----+---------+--------
3  |  Bolt   |   15
4  |  Cam    |   25

SELECT *
FROM SUPPLIER S
WHERE NOT EXISTS
(SELECT * FROM SELLS SE
WHERE SE.SNO = S.SNO);

SELECT MAX(subtable.avgprice)
FROM (SELECT AVG(P.PRICE) AS avgprice
FROM SUPPLIER S, PART P, SELLS SE
WHERE S.SNO = SE.SNO AND
P.PNO = SE.PNO
GROUP BY S.SNO) subtable;

SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNAME = 'Jones'
UNION
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNAME = 'Adams';

 SNO | SNAME |  CITY
-----+-------+--------
2  | Jones | Paris
3  | Adams | Vienna

SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO > 1
INTERSECT
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO < 3;

 SNO | SNAME |  CITY
-----+-------+--------
2  | Jones | Paris

SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO > 1
EXCEPT
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO > 3;

 SNO | SNAME |  CITY
-----+-------+--------
2  | Jones | Paris
3  | Adams | Vienna

/**//****strcat.c - contains strcat() and strcpy()
*
*       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
*       Strcpy() copies one string onto another.
*
*       Strcat() concatenates (appends) a copy of the source string to the
*       end of the destination string, returning the destination string.
*
*******************************************************************************/

#include <cruntime.h>
#include <string.h>

#ifndef _MBSCAT
#ifdef _MSC_VER
#pragma function(strcat,strcpy)
#endif  /* _MSC_VER */
#endif  /* _MBSCAT */

/**//****char *strcat(dst, src) - concatenate (append) one string to another
*
*Purpose:
*       Concatenates src onto the end of dest.  Assumes enough
*       space in dest.
*
*Entry:
*       char *dst - string to which "src" is to be appended
*       const char *src - string to be appended to the end of "dst"
*
*Exit:
*       The address of "dst"
*
*Exceptions:
*
*******************************************************************************/

char * __cdecl strcat (
        char * dst,
        const char * src
        )
{
        char * cp = dst;

        while( *cp )
                cp++;                   /**//* find end of dst */

        while( *cp++ = *src++ ) ;       /**//* Copy src to end of dst */

        return( dst );                  /**//* return dst */

}


/**//****char *strcpy(dst, src) - copy one string over another
*
*Purpose:
*       Copies the string src into the spot specified by
*       dest; assumes enough room.
*
*Entry:
*       char * dst - string over which "src" is to be copied
*       const char * src - string to be copied over "dst"
*
*Exit:
*       The address of "dst"
*
*Exceptions:
*******************************************************************************/

char * __cdecl strcpy(char * dst, const char * src)
{
        char * cp = dst;

        while( *cp++ = *src++ );               /**//* Copy src over dst */

        return( dst );
}

/**//****strcmp.c - routine to compare two strings (for equal, less, or greater)
*
*       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
*       Compares two string, determining their lexical order.
*
*******************************************************************************/

#include <cruntime.h>
#include <string.h>

#ifdef _MSC_VER
#pragma function(strcmp)
#endif  /* _MSC_VER */

/**//***
*strcmp - compare two strings, returning less than, equal to, or greater than
*
*Purpose:
*       STRCMP compares two strings and returns an integer
*       to indicate whether the first is less than the second, the two are
*       equal, or whether the first is greater than the second.
*
*       Comparison is done byte by byte on an UNSIGNED basis, which is to
*       say that Null (0) is less than any other character (1-255).
*
*Entry:
*       const char * src - string for left-hand side of comparison
*       const char * dst - string for right-hand side of comparison
*
*Exit:
*       returns -1 if src <  dst
*       returns  0 if src == dst
*       returns +1 if src >  dst
*
*Exceptions:
*
*******************************************************************************/

int __cdecl strcmp (
        const char * src,
        const char * dst
        )
{
        int ret = 0 ;

        while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
                ++src, ++dst;

        if ( ret < 0 )
                ret = -1 ;
        else if ( ret > 0 )
                ret = 1 ;

        return( ret );
}

　　很显然，在当前的任何关系数据库管理系统（DBMS）中，傻瓜也不可能做出不符合第一范式的数据库，因为这些DBMS不允许你把数据库表的一列再分成二列或多列。因此，你想在现有的DBMS中设计出不符合第一范式的数据库都是不可能的。

　　第二范式（2NF）：数据库表中不存在非关键字段对任一候选关键字段的部分函数依赖（部分函数依赖指的是存在组合关键字中的某些字段决定非关键字段的情况），也即所有非关键字段都完全依赖于任意一组候选关键字。
　假定选课关系表为SelectCourse(学号, 姓名, 年龄, 课程名称, 成绩, 学分)，关键字为组合关键字(学号, 课程名称)，因为存在如下决定关系：

　　(学号, 课程名称) → (姓名, 年龄, 成绩, 学分)

　　这个数据库表不满足第二范式，因为存在如下决定关系：

　　(课程名称) → (学分)

　　(学号) → (姓名, 年龄)

　　即存在组合关键字中的字段决定非关键字的情况。

　　由于不符合2NF，这个选课关系表会存在如下问题：

　　(1) 数据冗余：

　　同一门课程由n个学生选修，"学分"就重复n-1次；同一个学生选修了m门课程，姓名和年龄就重复了m-1次。

　　(2) 更新异常：

　　若调整了某门课程的学分，数据表中所有行的"学分"值都要更新，否则会出现同一门课程学分不同的情况。

　　(3) 插入异常：

　　假设要开设一门新的课程，暂时还没有人选修。这样，由于还没有"学号"关键字，课程名称和学分也无法记录入数据库。

　　(4) 删除异常：

　　假设一批学生已经完成课程的选修，这些选修记录就应该从数据库表中删除。但是，与此同时，课程名称和学分信息也被删除了。很显然，这也会导致插入异常。

　　把选课关系表SelectCourse改为如下三个表：

　　学生：Student(学号, 姓名, 年龄)；

　　课程：Course(课程名称, 学分)；

　　选课关系：SelectCourse(学号, 课程名称, 成绩)。

　　这样的数据库表是符合第二范式的，消除了数据冗余、更新异常、插入异常和删除异常。

　　另外，所有单关键字的数据库表都符合第二范式，因为不可能存在组合关键字。

　　第三范式（3NF）：在第二范式的基础上，数据表中如果不存在非关键字段对任一候选关键字段的传递函数依赖则符合第三范式。所谓传递函数依赖，指的是如果存在"A → B → C"的决定关系，则C传递函数依赖于A。因此，满足第三范式的数据库表应该不存在如下依赖关系：

　　关键字段 → 非关键字段x → 非关键字段y

假定学生关系表为Student(学号, 姓名, 年龄, 所在学院, 学院地点, 学院电话)，关键字为单一关键字"学号"，因为存在如下决定关系：

　　(学号) → (姓名, 年龄, 所在学院, 学院地点, 学院电话)

　　这个数据库是符合2NF的，但是不符合3NF，因为存在如下决定关系：

　　(学号) → (所在学院) → (学院地点, 学院电话)

　　即存在非关键字段"学院地点"、"学院电话"对关键字段"学号"的传递函数依赖。

　　它也会存在数据冗余、更新异常、插入异常和删除异常的情况，读者可自行分析得知。

　　把学生关系表分为如下两个表：

　　学生：(学号, 姓名, 年龄, 所在学院)；

　　学院：(学院, 地点, 电话)。

　　这样的数据库表是符合第三范式的，消除了数据冗余、更新异常、插入异常和删除异常。

　　鲍依斯-科得范式（BCNF）：在第三范式的基础上，数据库表中如果不存在任何字段对任一候选关键字段的传递函数依赖则符合第三范式。

　假设仓库管理关系表为StorehouseManage(仓库ID, 存储物品ID, 管理员ID, 数量)，且有一个管理员只在一个仓库工作；一个仓库可以存储多种物品。这个数据库表中存在如下决定关系：

　　(仓库ID, 存储物品ID) →(管理员ID, 数量)

　　(管理员ID, 存储物品ID) → (仓库ID, 数量)

　　所以，(仓库ID, 存储物品ID)和(管理员ID, 存储物品ID)都是StorehouseManage的候选关键字，表中的唯一非关键字段为数量，它是符合第三范式的。但是，由于存在如下决定关系：

　　(仓库ID) → (管理员ID)

　　(管理员ID) → (仓库ID)

　　即存在关键字段决定关键字段的情况，所以其不符合BCNF范式。它会出现如下异常情况：

　　(1) 删除异常：

　　当仓库被清空后，所有"存储物品ID"和"数量"信息被删除的同时，"仓库ID"和"管理员ID"信息也被删除了。

　　(2) 插入异常：

　　当仓库没有存储任何物品时，无法给仓库分配管理员。

　　(3) 更新异常：

　　如果仓库换了管理员，则表中所有行的管理员ID都要修改。

　　把仓库管理关系表分解为二个关系表：

　　仓库管理：StorehouseManage(仓库ID, 管理员ID)；

　　仓库：Storehouse(仓库ID, 存储物品ID, 数量)。

　　这样的数据库表是符合BCNF范式的，消除了删除异常、插入异常和更新异常。

范式应用

　　我们来逐步搞定一个论坛的数据库，有如下信息：

　　（1） 用户：用户名，email，主页，电话，联系地址

　　（2） 帖子：发帖标题，发帖内容，回复标题，回复内容

　　第一次我们将数据库设计为仅仅存在表：
　　

用户名

email

主页

电话

联系地址

发帖标题

发帖内容

回复标题

回复内容

　　这个数据库表符合第一范式，但是没有任何一组候选关键字能决定数据库表的整行，唯一的关键字段用户名也不能完全决定整个元组。我们需要增加"发帖ID"、"回复ID"字段，即将表修改为：

用户名

email

主页

电话

联系地址

发帖ID

发帖标题

发帖内容

回复ID

回复标题

回复内容

　　这样数据表中的关键字(用户名，发帖ID，回复ID)能决定整行：

　　(用户名,发帖ID,回复ID) → (email,主页,电话,联系地址,发帖标题,发帖内容,回复标题,回复内容)

　　但是，这样的设计不符合第二范式，因为存在如下决定关系：

　　(用户名) → (email,主页,电话,联系地址)

　　(发帖ID) → (发帖标题,发帖内容)

　　(回复ID) → (回复标题,回复内容)

　　即非关键字段部分函数依赖于候选关键字段，很明显，这个设计会导致大量的数据冗余和操作异常。

　　我们将数据库表分解为（带下划线的为关键字）：

　　（1） 用户信息：用户名，email，主页，电话，联系地址

　　（2） 帖子信息：发帖ID，标题，内容

　　（3） 回复信息：回复ID，标题，内容

　　（4） 发贴：用户名，发帖ID

　　（5） 回复：发帖ID，回复ID

　　这样的设计是满足第1、2、3范式和BCNF范式要求的，但是这样的设计是不是最好的呢？

　　不一定。

　　观察可知，第4项"发帖"中的"用户名"和"发帖ID"之间是1：N的关系，因此我们可以把"发帖"合并到第2项的"帖子信息"中；第5项"回复"中的"发帖ID"和"回复ID"之间也是1：N的关系，因此我们可以把"回复"合并到第3项的"回复信息"中。这样可以一定量地减少数据冗余，新的设计为：

　　（1） 用户信息：用户名，email，主页，电话，联系地址

　　（2） 帖子信息：用户名，发帖ID，标题，内容

　　（3） 回复信息：发帖ID，回复ID，标题，内容

　　数据库表1显然满足所有范式的要求；

　　数据库表2中存在非关键字段"标题"、"内容"对关键字段"发帖ID"的部分函数依赖，即不满足第二范式的要求，但是这一设计并不会导致数据冗余和操作异常；

　　数据库表3中也存在非关键字段"标题"、"内容"对关键字段"回复ID"的部分函数依赖，也不满足第二范式的要求，但是与数据库表2相似，这一设计也不会导致数据冗余和操作异常。

　　由此可以看出，并不一定要强行满足范式的要求，对于1：N关系，当1的一边合并到N的那边后，N的那边就不再满足第二范式了，但是这种设计反而比较好！

　　对于M：N的关系，不能将M一边或N一边合并到另一边去，这样会导致不符合范式要求，同时导致操作异常和数据冗余。
对于1：1的关系，我们可以将左边的1或者右边的1合并到另一边去，设计导致不符合范式要求，但是并不会导致操作异常和数据冗余。

　　结论

　　满足范式要求的数据库设计是结构清晰的，同时可避免数据冗余和操作异常。这并意味着不符合范式要求的设计一定是错误的，在数据库表中存在1：1或1：N关系这种较特殊的情况下，合并导致的不符合范式要求反而是合理的。

　　在我们设计数据库的时候，一定要时刻考虑范式的要求。