1、原码的定义

①小数原码的定义 

	[X]原 =		X	0≤X ＜1
			1－ X	－1 ＜ X ≤ 0

 例如： X=+0.1011 , [X]原= 01011
        X=－0.1011  [X]原= 11011

②整数原码的定义

	[X]原 =		X	0≤X ＜2n
			2n－X	－ 2n ＜ X ≤ 0

2、补码的定义

①小数补码的定义

	[X]补 =		X	0≤X ＜1
			2＋ X	－1 ≤ X ＜ 0

例如：  X=+0.1011,   [X]_补= 01011
        X=－0.1011,  [X]_补= 10101

②整数补码的定义 

	[X]补 =		X	0≤X ＜2n
			2n+1＋X	－ 2n ≤ X ＜ 0

3、反码的定义

①小数反码的定义 

	[X]反 =		X	0≤X ＜1
			2－2n-1－X	－1 ＜ X ≤ 0

例如：   X=+0.1011      [X]_反= 01011
         X=－0.1011     [X]_反= 10100

②整数反码的定义

	[X]反 =		X	0≤X ＜2n
			2n+1－1－X	－ 2n ＜ X ≤ 0

4.移码：移码只用于表示浮点数的阶码，所以只用于整数。

①移码的定义：设由1位符号位和n位数值位组成的阶码，则 [X]_移=2ⁿ + X     -2ⁿ≤X ≤ 2ⁿ
例如： X=＋1011     [X]_移=11011     符号位“1”表示正号
              X=－1011     [X]_移=00101     符号位“0”表示负号

②移码与补码的关系： [X]移与[X]补的关系是符号位互为反码，
例如： X=＋1011     [X]_移=11011     [X]_补=01011 
              X=－1011     [X]_移=00101     [X]_补=10101 

③移码运算应注意的问题：
◎对移码运算的结果需要加以修正，修正量为2ⁿ ，即对结果的符号位取反后才是移码形式的正确结果。
◎移码表示中，0有唯一的编码——1000…00，当出现000…00时（表示－2ⁿ），属于浮点数下溢。

二、补码加、减运算规则

1、运算规则

[X＋Y]_补= [X]_补＋ [Y]_补
[X－Y]_补= [X]_补＋ [－Y]_补

若已知[Y]_补，求[－Y]_补的方法是：将[Y]_补的各位（包括符号位）逐位取反再在最低位加1即可。
例如：[Y]_补= 101101 [－Y]_补= 010011 

2、溢出判断，一般用双符号位进行判断：

符号位00 表示正数 11 表示负数
结果的符号位为01时，称为上溢；为10时，称为下溢

例题：设x=0.1101，y=－0.0111，符号位为双符号位
用补码求x+y，x－y 
[x]补+[y]补=00 1101+11 1001=00 0110 
[x－y]补=[x]补+[－y]补=00 1101+00 0111=01 0100
结果错误，正溢出

三、原码一位乘的实现：

设X=0.1101，Y=－0. 1011，求X*Y
解：符号位单独处理， x_符＋ y_符
数值部分用原码进行一位乘，如下图所示：
   

四、原码一位除的实现：一般用不恢复余数法（加减交替法）

§2.5 浮点运算与浮点运算器

1. 二进制数与十进制数之间的转换

⑴二进制数转换成十进制数 

[例](11111001001)₂=1×2¹⁰+1×2⁹+1×2⁸+1×2⁷+1×2⁶+0×2⁵+0×2⁴

                  +1×2³+0×2²+0×2¹+1×2⁰

                   =(1993)₁₀

(1011.101)₂=1×2³+0×2²+1×2¹+1×2⁰+1×2^-1+0×2^-2+1×2^-3  =(11.625)₁₀

⑵十进制数转换成二进制数 

①十进制整数转换成二进制整数(除基(2)取余法)

[例]

2   1993

   2   996               …………1…………0位     低位二进制整数

  2   498              …………0…………1位   

  2   249             …………0…………2位

  2   124            …………1…………3位

   2   62            …………0…………4位

  2   31           …………0…………5位

  2   15          …………1…………6位

  2   7          …………1…………7位

  2   3         …………1…………8位

  2   1        …………1…………9位

   0        …………1…………10位     高位二进制整数

注意,除到0商时结束2除步,回写(从高位回到低位)余数便是所求二进制数,即:(1993)₁₀=(11111001001)₂

②十进制纯小数转换成二进制纯小数(乘基(2)取整法)

[例]

                                0.625

                                    2

                  2^-1位…  1.  250         高位二进制小数

                                    2

                  2^-2位…   0. 500

                                    2

                  2^-3位       1.000         低位二进制小数

纯小数位被全乘为0时,得准确二进制纯小数;否则(纯小数位永远被2乘不为全是0)只能化成满足某一精确度要求的二进制小数的近似值。例中(0.625)₁₀=(0.101)₂是准确值,其中101是顺写的积整位(从高位到低位)数。

2. 二进制数与八进制数之间的转换

⑴二进制数转换成八进制数(三位分组转换法,即合三为一法) 

[例]将二进制数11010001011.11011用三位分组转换的方法转换成八进制数。

①从小数点起对整数位向左,对小数位向右三位分一组,不足三位时,在最外端加补0位,使之都成为三位：

(填入0位)0→011 010 001 011.110 110←0(填入0位)

②将三位一组二进制数分别转换成八进制数,并按原位置次序写成新的记数数,即得与原数等值的八进制数:3213.66

③从而有:(11010001011.11011)₂=(3213.66)₈

所以这样做,是因为八进制数的不同数字恰是8个三位二进制数。

⑵八进制数转换成二进制数 

将八进制数转换成二进制数时,正是上述方法的逆(一分为三法)。只是注意要在转换成二进制数后,将相当于被加补的0位上的那些0略去,这些0在二进制记数中是可有可无的,它们并不影响记数值。

[例](3213.66)₈=(011 010 001 011.110 110)₂=(11010001011.11011)₂

八进制数与十进制数之间的转换,我们至少可以这样做：

①通过二进制数作中间过渡,将它们互转：

(17)₁₀=(10001)₂=(010 001)₂=(21)₈

②用“除基(8)取余法”将十进制整数转换成八进制整数,用“乘基(8)取整法“将十进制纯小数转换成八进制纯小数;至于将八进制数转换成十进制数,只要“按位乘基幂”即可：

[例]   ①由 8  17                 ②∵     0.6875

                                                   8

             8  2……1(低位)        (高位)  5. 500

                 0                               8

                  ……2(高位)        (低位)   4.0000

            得(17)₁₀=(21)₈                ∴(0.6875)₁₀=(0.54)₈

③于是,(17.6875)₁₀=(21.54)₈

④而(21.54)₈=2×8¹+1×8⁰+5×8^-1+4×8^-2(按位乘基幂)

         =16+1+5×0.125+4×0.015625=(17.6875)₁₀

3. 二进制数与十六进制数之间的转换

⑴二进制数转换成十六进制数(四位分组转换法,即合四为一法) 

[例](101101111100011.110101111)₂=(0101 1011 1110 0011.1101 0111 1000)₂

                            =(5BE3.D78)₁₆

⑵十六进制数转换成二进制数(四位分组转换法的逆方法,即一分为四法) 

[例](5BE3.D78)₁₆=(0101 1011 1110 0011.1101 0111 1000)₂

              =(101101111100011.110101111)₂

十六进制数与十进制数之间的转换和八进制数与十进制数之间的转换的方法完全相同,对基16操作起来也很容易,这里就不再赘述了。

需要强调的是：计算机能够处理的任何信息,其数据形式在计算机内部都以0和1的方式进行存储。任何信息要想存入计算机,都必须经过一个转换装置,先把计算机要处理的信息转换成仅由0和1组成的二进制代码之后再存入计算机。要把存储于计算机内的各种信息输出来,也必须再经过转换装置把二进制信息转换成人们所熟悉的和常用的符号。这些工作是由计算机自动完成的,并不需要用户干预。

计算机所能处理和存储的信息是大量的,其软件系统要适应发展的需要,对表示信息的二进制数码(代码)必须进行统一的编码,以保证计算机的通用性,否则就会造成在互换和交流时的混乱。

通常,将十进制数字、英文字母和一些专用符号等数据都用一定长度的二进制数来表示,称作编码;用编码表示的数据就称代码。使用计算机时,程序、控制命令、数据等在其内部(机器级上)一律都用代码。现在,已有许多种编码方法,但被普遍使用的是下述的几种方法。

PowerPoint 的一大特色就是可以使某一演示文稿的多张幻灯片具有一致的格式。设置幻灯片的总体格式有三种方法：母版、配色方案、设计模板。

母版

每一份演示文稿都有两种母版，即幻灯片母版和标题母版。幻灯片母版控制所有幻灯片的格式；标题母版控制标题幻灯片的格式和位置，并能控制指定为标题幻灯片的幻灯片，例如某部分的开始。

母版中包含了设定的幻灯片格式占位符。这些占位符就是母版不同位置的虚线方框，在这些方框中可以设置所有幻灯片中出现的标题、文本、图表、表格、组织结构图、剪贴画及背景等项目。更改幻灯片母版，会影响所有基于母版的演示文稿幻灯片，这种更改也会应用于标题幻灯片中。

同样道理，更改标题母版的版式，所有标题幻灯片也会随之改变。可以在某一张幻灯片中更改母版设置，例如背景和母版不同或填充颜色不属于母版配色方案。这些特定设置的幻灯片不随母版更改而变化，但随时都可以将母版的设置还原到已改变的幻灯片上。例如，如果幻灯片上有隐藏的背景项，只要单击【格式(O)】菜单上的“背景”命令，清除“忽略母版的背景图形”复选框，即可显示背景项。

幻灯片母版上的标题、文本、日期幻灯片编号和页脚等占位符可以删除。还原被删除的占位符，在幻灯片母版视图中单击【格式(D)】菜单，单击“母版格式”命令，单击需要添加项的复选框，单击“确定”按钮。只有在幻灯片母版上删除某项占位符后，才能使用相应的复选框。不要在母版上键入文字或插入对象，应该切换到幻灯片或大纲视图后操作。

配色方案

配色方案由八种颜色组成，用于演示文稿的主要颜色，例如文本、背景、填充、强调文字所用的颜色。方案中的每种颜色都会自动用于幻灯片上的不同组件。

用模板创建演示文稿时，程序已为每一个模板选择了一种配色方案。演示文稿的配色方案可以更换，单击【格式(D)】菜单，单击“幻灯片配色方案”命令，挑选或自定义一种配色方案，用于某张或全部演示文稿。通过这种方式，可以很容易地更改演示文稿的配色方案，并确保新的配色方案和演示文稿中的其他幻灯片相互调和，如想将一张幻灯片的配色方案应用于另一张中，可在幻灯片浏览视图中选择具有所需配色方案的幻灯片，单击“常用”工具栏“格式刷”键 ，可以重新着色一张幻灯片；双击“格式刷”键，依次单击要应用配色方案的一张或者多张幻灯片，可同时重新着色多张幻灯片。

配色方案中除了预设的八种颜色，还有许多其他颜色可供使用。按“配色方案”对话框“自定义”选项卡中“更改颜色”按钮，可使用“标准”或“自定义”选项卡中的颜色改变幻灯片组件，该颜色会自动添加到各个颜色卡中，所有文本、阴影、项目符号、背景、和线条都能使用该颜色。

添加的颜色将出现在配色方案的八种颜色的下面，最多可以添加和显示八种颜色。如果添加的颜色超过八种，最新的颜色将出现在调色板的第一位，而最旧的颜色被删除。即使更改配色方案，添加到颜色菜单中的颜色仍然保持不变。同样地，以这些颜色着色的文本或对象也不会改变。

如果经常使用一些不属于配色方案内的特定颜色，此功能非常有用。

设计模板

PowerPoint 提供两种模板：设计模板和内容模板。设计模板包含预定义的格式和配色方案，可以应用到任意演示文稿中创建自定义的外观；内容模板包含的格式和配色方案与设计模板相同，不同的是加上了针对特定主题提供的建议内容。在演示文稿中应用设计模板时，新模板的母版和配色方案将取代原演示文稿的母版和配色方案。应用设计模板之后，不论自动版式是什么，添加的每张新幻灯片都会拥有相同的自定义外观。

PowerPoint 提供了各种专业设计的模板，可在新建演示文稿时选用模板；对已建立的演示文稿也可更改模板，单击“常规任务”工具栏中的“应用设计模板”按钮，在对话框的列表中选择合适的模板。

用户还可以添加自己设计的模板。单击【文件(F)】菜单中的“另存为”命令，在“另存为”对话框中，将保存位置选择在“/Microsoft Office/template/演示文稿设计”文件夹中，“保存类型”定为“演示文稿模板”，输入模板的“文件名”，即可将自己设计的模板保存，并在“新建演示文稿”对话框的“演示文稿设计”选项卡和“常规任务”工具栏中的“应用设计模板”按钮激活的对话框中列出。如果其他设置不变，“另存为”选择“演示文稿”文件夹，则可做为内容模板，在“新建演示文稿”对话框的“演示文稿”选项卡中列出。

配色方案

配色方案由八种颜色组成，用于演示文稿的主要颜色，例如文本、背景、填充、强调文字所用的颜色。方案中的每种颜色都会自动用于幻灯片上的不同组件。

用模板创建演示文稿时，程序已为每一个模板选择了一种配色方案。演示文稿的配色方案可以更换，单击【格式(D)】菜单，单击“幻灯片配色方案”命令，挑选或自定义一种配色方案，用于某张或全部演示文稿。通过这种方式，可以很容易地更改演示文稿的配色方案，并确保新的配色方案和演示文稿中的其他幻灯片相互调和，如想将一张幻灯片的配色方案应用于另一张中，可在幻灯片浏览视图中选择具有所需配色方案的幻灯片，单击“常用”工具栏“格式刷”键 ，可以重新着色一张幻灯片；双击“格式刷”键，依次单击要应用配色方案的一张或者多张幻灯片，可同时重新着色多张幻灯片。

配色方案中除了预设的八种颜色，还有许多其他颜色可供使用。按“配色方案”对话框“自定义”选项卡中“更改颜色”按钮，可使用“标准”或“自定义”选项卡中的颜色改变幻灯片组件，该颜色会自动添加到各个颜色卡中，所有文本、阴影、项目符号、背景、和线条都能使用该颜色。

添加的颜色将出现在配色方案的八种颜色的下面，最多可以添加和显示八种颜色。如果添加的颜色超过八种，最新的颜色将出现在调色板的第一位，而最旧的颜色被删除。即使更改配色方案，添加到颜色菜单中的颜色仍然保持不变。同样地，以这些颜色着色的文本或对象也不会改变。

如果经常使用一些不属于配色方案内的特定颜色，此功能非常有用。

设计模板

PowerPoint 提供两种模板：设计模板和内容模板。设计模板包含预定义的格式和配色方案，可以应用到任意演示文稿中创建自定义的外观；内容模板包含的格式和配色方案与设计模板相同，不同的是加上了针对特定主题提供的建议内容。在演示文稿中应用设计模板时，新模板的母版和配色方案将取代原演示文稿的母版和配色方案。应用设计模板之后，不论自动版式是什么，添加的每张新幻灯片都会拥有相同的自定义外观。

PowerPoint 提供了各种专业设计的模板，可在新建演示文稿时选用模板；对已建立的演示文稿也可更改模板，单击“常规任务”工具栏中的“应用设计模板”按钮，在对话框的列表中选择合适的模板。

用户还可以添加自己设计的模板。单击【文件(F)】菜单中的“另存为”命令，在“另存为”对话框中，将保存位置选择在“/Microsoft Office/template/演示文稿设计”文件夹中，“保存类型”定为“演示文稿模板”，输入模板的“文件名”，即可将自己设计的模板保存，并在“新建演示文稿”对话框的“演示文稿设计”选项卡和“常规任务”工具栏中的“应用设计模板”按钮激活的对话框中列出。如果其他设置不变，“另存为”选择“演示文稿”文件夹，则可做为内容模板，在“新建演示文稿”对话框的“演示文稿”选项卡中列出。

大纲、备注页和讲义的应用

大纲演示文稿在大纲视图中以大纲形式显示。大纲由每张幻灯片的标题和正文组成。

大纲视图是组织和创建演示文稿内容的理想方式。在 PowerPoint 中创建大纲，可使用“内容提示向导”，或从其他应用程序（如 Microsoft Word）导入大纲。

每张幻灯片的标题都会出现在编号和图标的旁边，正文在每个标题的下面。正文的缩进可多达五层。在大纲视图中，可以重新排列幻灯片、移动整张幻灯片、编辑标题和正文。在大纲视图可以看见屏幕上所有的标题和正文，组织内容非常容易。例如，重排幻灯片或项目符号，只要选定要移动的内容，再拖动到新位置即可。切换到大纲视图时，将显示“大纲”工具栏，使用其中的工具按钮，可以快速组织演示文稿，如更改项目符号的缩进层次，将项目符号或整张幻灯片在大纲中前后移动，显示或隐藏格式，以及展开或压缩选定幻灯片文本等

备注页和讲义为了辅助演示，PowerPoint 的每张幻灯片都有一个备注页，其中包含幻灯片的缩图及供演讲者备注使用的空间。备注页可以打印，发给观众，在运行演示文稿时作为提示重点。也可以打印每页包含二张、三张、或六张幻灯片的讲义，帮助观众了解演示文稿的内容。

备注和讲义都具有母版，可以在母版上添加要在每页显示的项目。方法是：单击【文件(F)】菜单中的“打印”命令，单击“打印内容”方框右侧的下拉箭头，如果只需显示幻灯片的内容，选择单击某个“讲义”。如果要包括演讲者备注和幻灯片，单击“备注页”。如果要在打印内容中包括幻灯片标题和重点，也可以选择“大纲视图”。

版式的应用

创建新的幻灯片，可以单击“常用”工具栏的“新建”或“常规任务”工具栏的“新幻灯片”按钮。

在“新幻灯片”对话框中的24种不同版面设置的自动版式中，根据需要任选一种。例如，有一种版式提供标题、文本及图表的占位符，另一种则提供标题和剪贴画的占位符。标题和文本占位符会采用演示文稿的幻灯片母版格式。可以对占位符执行移动、调整大小或重新设置格式等操作，使它们与幻灯片母版不同。已经创建的幻灯片也可以更改其版式。单击“常规任务”工具栏上的“幻灯片版面设置”按钮，从中选择一种版式。如果新的版式中没有所需的占位符，例如已经制作了一份图表，但新版式并不提供图表占位符，这时信息也不会丢失。所有已创建的对象仍然存在，但必须重排这些对象使它们配合新的版式。

那么什么是ESB呢？

我们知道SOA体系结构要求企业里面所有的和业务相关的应用程序都应该提供webservice的接口。那么一旦这一步实现了之后，所有的应用程序面临的问题就是如何去调用这些或者说这么多接口，当然使用webservice的客户端采取同步调用的方式当然是可以的。同时如果企业应用有可伸缩性要求，那么也可以采取异步的消息调用机制。而ESB就是采用了消息封装这一思想，把所有对服务的调用都通过统一的消息接口封装起来，无论消息是同步的还是异步的。此外ESB还可以对企业的其他消息服务也提供同样的借口，例如mail,JMS,IBM MQ,MSMQ等等。

ESB可以有那些用 ?

ESB不是万能的,他不是一个应用程序框架,也不是一个企业应用的解决方案.它只是一个基于消息的调用企业服务的通信模块!你可以把它嵌入到你的应用程序框架中,例如嵌入到spring容器里面,或者嵌入到工作流系统中.它的作用是对企业里面的SOA服务的调用提供一个框架和简便的方法.

ESB距离实际的企业应用还有哪些不足?

ESB目前有很多商业方案,也有很多开源产品,例如ObjectWeb,CodeHaus,Sourceforge都有这样的开源项目.距离真正成熟还有一段距离,另外各家厂商都各自为阵,目前JCP还没有这项技术的草案,标准的指定也还有很长的距离.当然,目前的状态和SOA一样.相信等SOA真正普及的时候,ESB会更加的成熟.

（1）接收验证用户数字证书的申请。
（2）确定是否接受用户数字证书的申请，即证书的审批。
（3）向申请者颁发（或拒绝颁发）数字证书。
（4）接收、处理用户的数字证书更新请求。
（5）接收用户数字证书的查询、撤销。
（6）产生和发布证书的有效期。
（7）数字证书的归档。
（8）密钥归档。
（9）历史数据归档。

　　再看例子：

　　例四：

　　1、chara[20];
　　2、int*ptr=a;
　　...
　　...
　　3、ptr+=5;
　　在这个例子中，ptr被加上了5，编译器是这样处理的：将指针ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由于地址的单位是字节，故现在的ptr所指向的地址比起加5后的ptr所指向的地址来说，向高地址方向移动了20个字节。在这个例子中，没加5前的ptr指向数组a的第0号单元开始的四个字节，加5后，ptr已经指向了数组a的合法范围之外了。虽然这种情况在应用上会出问题，但在语法上却是可以的。这也体现出了指针的灵活性。

如果上例中，ptr是被减去5，那么处理过程大同小异，只不过ptr的值是被减去5乘sizeof(int)，新的ptr指向的地址将比原来的ptr所指向的地址向低地址方向移动了20个字节。
　　总结一下，一个指针ptrold加上一个整数n后，结果是一个新的指针ptrnew，ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值增加了n乘sizeof(ptrold所指向的类型)个字节。就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向高地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。
　　一个指针ptrold减去一个整数n后，结果是一个新的指针ptrnew，ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向的类型)个字节，就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。
运算符&和*
这里&是取地址运算符，*是...书上叫做"间接运算符"。
　　&a的运算结果是一个指针，指针的类型是a的类型加个*，指针所指向的类型是a的类型，指针所指向的地址嘛，那就是a的地址。
　　*p的运算结果就五花八门了。总之*p的结果是p所指向的东西，这个东西有这些特点：它的类型是p指向的类型，它所占用的地址是p所指向的地址。
　　例五：
inta=12;
intb;
int*p;
int**ptr;
p=&a;
//&a的结果是一个指针，类型是int*，指向的类型是int，指向的地址是a的地址。
*p=24;
//*p的结果，在这里它的类型是int，它所占用的地址是p所指向的地址，显然，*p就是变量a。
ptr=&p;
//&p的结果是个指针，该指针的类型是p的类型加个*，在这里是int **。该指针所指向的类型是p的类型，这里是int*。该指针所指向的地址就是指针p自己的地址。
*ptr=&b;
//*ptr是个指针，&b的结果也是个指针，且这两个指针的类型和所指向的类型是一样的，所以用&b来给*ptr赋值就是毫无问题的了。
**ptr=34;
//*ptr的结果是ptr所指向的东西，在这里是一个指针，对这个指针再做一次*运算，结果就是一个int类型的变量。
　　指针表达式
一个表达式的最后结果如果是一个指针，那么这个表达式就叫指针表式。
　　下面是一些指针表达式的例子：
　　例六：
inta,b;
intarray[10];
int*pa;
pa=&a;//&a是一个指针表达式。
int**ptr=&pa;//&pa也是一个指针表达式。
*ptr=&b;//*ptr和&b都是指针表达式。
pa=array;
pa++;//这也是指针表达式。
例七：
char*arr[20];
char**parr=arr;//如果把arr看作指针的话，arr也是指针表达式
char*str;
str=*parr;//*parr是指针表达式
str=*(parr+1);//*(parr+1)是指针表达式
str=*(parr+2);//*(parr+2)是指针表达式
　　由于指针表达式的结果是一个指针，所以指针表达式也具有指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。

　　好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，否则就不是一个左值。
　　在例七中，&a不是一个左值，因为它还没有占据明确的内存。*ptr是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了自己的位置，那么*ptr当然也有了自己的位置。
　　数组和指针的关系
　　数组的数组名其实可以看作一个指针。看下例：
　　例八：
intarray[10]={0,1,2,3,4,5,6,7,8,9},value;
...
...
value=array[0];//也可写成：value=*array;
value=array[3];//也可写成：value=*(array+3);
value=array[4];//也可写成：value=*(array+4);
上例中，一般而言数组名array代表数组本身，类型是int[10]，但如果把array看做指针的话，它指向数组的第0个单元，类型是int*，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。

　　例九：
char*str[3]={
　"Hello,thisisasample!",
　"Hi,goodmorning.",
　"Helloworld"
};
chars[80]；
strcpy(s,str[0]);//也可写成strcpy(s,*str);
strcpy(s,str[1]);//也可写成strcpy(s,*(str+1));
strcpy(s,str[2]);//也可写成strcpy(s,*(str+2));
上例中，str是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0号单元，它的类型是char**，它指向的类型是char*。
*str也是一个指针，它的类型是char*，它所指向的类型是char，它指向的地址是字符串"Hello,thisisasample!"的第一个字符的地址，即'H'的地址。 str+1也是一个指针，它指向数组的第1号单元，它的类型是char**，它指向的类型是char*。

　　*(str+1)也是一个指针，它的类型是char*，它所指向的类型是char，它指向 "Hi,goodmorning."的第一个字符'H'，等等。

　　下面总结一下数组的数组名的问题。声明了一个数组TYPEarray[n]，则数组名称array就有了两重含义：第一，它代表整个数组，它的类型是TYPE[n]；第二 ，它是一个指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。
　　在不同的表达式中数组名array可以扮演不同的角色。
　　在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数测出的是整个数组的大小。
在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的值。sizeof(*array)测出的是数组单元的大小。
　　表达式array+n（其中n=0，1，2，....。）中，array扮演的是指针，故array+n的结果是一个指针，它的类型是TYPE*，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。
例十
intarray[10];
int(*ptr)[10];
ptr=&array;：
上例中ptr是一个指针，它的类型是int(*)[10]，他指向的类型是int[10] ，我们用整个数组的首地址来初始化它。在语句ptr=&array中，array代表数组本身。

　　本节中提到了函数sizeof()，那么我来问一问，sizeof(指针名称)测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？答案是前者。例如：
int(*ptr)[10];
　　则在32位程序中，有：
sizeof(int(*)[10])==4
sizeof(int[10])==40
sizeof(ptr)==4
实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小。
指针和结构类型的关系
可以声明一个指向结构类型对象的指针。
　　例十一：
structMyStruct
{
　inta;
　intb;
　intc;
}
MyStructss={20,30,40};
//声明了结构对象ss，并把ss的三个成员初始化为20，30和40。
MyStruct*ptr=&ss;
//声明了一个指向结构对象ss的指针。它的类型是MyStruct*,它指向的类型是MyStruct。
int*pstr=(int*)&ss;
//声明了一个指向结构对象ss的指针。但是它的类型和它指向的类型和ptr是不同的。
　　请问怎样通过指针ptr来访问ss的三个成员变量？
　　答案：
ptr->a;
ptr->b;
ptr->c;
　　又请问怎样通过指针pstr来访问ss的三个成员变量？
　　答案：
*pstr；//访问了ss的成员a。
*(pstr+1);//访问了ss的成员b。
*(pstr+2)//访问了ss的成员c。
　　虽然我在我的MSVC++6.0上调式过上述代码，但是要知道，这样使用pstr来访问结构成员是不正规的，为了说明为什么不正规，让我们看看怎样通过指针来访问数组的各个单元：
　　例十二：
intarray[3]={35,56,37};
int*pa=array;
　　通过指针pa访问数组array的三个单元的方法是：
*pa;//访问了第0号单元
*(pa+1);//访问了第1号单元
*(pa+2);//访问了第2号单元

从格式上看倒是与通过指针访问结构成员的不正规方法的格式一样。
　　所有的C/C++编译器在排列数组的单元时，总是把各个数组单元存放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员之间加若干个"填充字节"，这就导致各个成员之间可能会有若干个字节的空隙。
　　所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，嘿，这倒是个不错的方法。
过指针访问结构成员的正确方法应该是象例十二中使用指针ptr的方法。
　　指针和函数的关系
　　可以把一个指针声明成为一个指向函数的指针。intfun1(char*,int);
int(*pfun1)(char*,int);
pfun1=fun1;
....
....
inta=(*pfun1)("abcdefg",7);//通过函数指针调用函数。
可以把指针作为函数的形参。在函数调用语句中，可以用指针表达式来作为实参。
　　例十三：
intfun(char*);
inta;
charstr[]="abcdefghijklmn";
a=fun(str);
...
...
intfun(char*s)
{
intnum=0;
for(inti=0;i{
num+=*s;s++;
}
returnnum;
}
　　这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自加1运算。
指针类型转换
当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向的类型是一样的。
　　例十四：
　　1、floatf=12.3;
　　2、float*fptr=&f;
　　3、int*p;
　　　在上面的例子中，假如我们想让指针p指向实数f，应该怎么搞？是用下面的语句吗？

　　p=&f;

　　不对。因为指针p的类型是int*，它指向的类型是int。表达式&f的结果是一个指针，指针的类型是float*,它指向的类型是float。两者不一致，直接赋值的方法是不行的。至少在我的MSVC++6.0上，对指针的赋值语句要求赋值号两边的类型一致，所指向的类型也一致，其它的编译器上我没试过，大家可以试试。为了实现我们的目的，需要进行"强制类型转换"：
p=(int*)&f;
如果有一个指针p，我们需要把它的类型和所指向的类型改为TYEP*TYPE， 那么语法格式是：
　　(TYPE*)p；
　　这样强制类型转换的结果是一个新指针，该新指针的类型是TYPE*，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都没有被修改。
　　一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结合过程中，也会发生指针类型的转换。
　　例十五：
voidfun(char*);
inta=125,b;
fun((char*)&a);
...
...
voidfun(char*s)
{
charc;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}
}
注意这是一个32位程序，故int类型占了四个字节，char类型占一个字节。函数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调用语句中，实参&a的结果是一个指针，它的类型是int*，它指向的类型是int。形参这个指针的类型是char*，它指向的类型是char。这样，在实参和形参的结合过程中，我们必须进行一次从int*类型到char*类型的转换。结合这个例子，我们可以这样来想象编译器进行转换的过程：编译器先构造一个临时指针char*temp， 然后执行temp=(char*)&a，最后再把temp的值传递给s。所以最后的结果是：s的类型是char*,它指向的类型是char，它指向的地址就是a的首地址。

　　我们已经知道，指针的值就是指针指向的地址，在32位程序中，指针的值其实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象下面的语句：
unsignedinta;
TYPE*ptr;//TYPE是int，char或结构类型等等类型。
...
...
a=20345686;
ptr=20345686;//我们的目的是要使指针ptr指向地址20345686（十进制
）
ptr=a;//我们的目的是要使指针ptr指向地址20345686（十进制）
编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗？不，还有办法：
unsignedinta;
TYPE*ptr;//TYPE是int，char或结构类型等等类型。
...
...
a=某个数，这个数必须代表一个合法的地址；
ptr=(TYPE*)a；//呵呵，这就可以了。
严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。上面强调了a的值必须代表一个合法的地址，否则的话，在你使用ptr的时候，就会出现非法操作错误。

　　想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完 全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个整数当作一个地址赋给一个指针：
　　例十六：
inta=123,b;
int*ptr=&a;
char*str;
b=(int)ptr;//把指针ptr的值当作一个整数取出来。
str=(char*)b;//把这个整数的值当作一个地址赋给指针str。
　　现在我们已经知道了，可以把指针的值当作一个整数取出来，也可以把一个整数值当作地址赋给一个指针。
　　指针的安全问题
看下面的例子：
　　例十七：
chars='a';
int*ptr;
ptr=(int*)&s;
*ptr=1298；
　　指针ptr是一个int*类型的指针，它指向的类型是int。它指向的地址就是s的首地址。在32位程序中，s占一个字节，int类型占四个字节。最后一条语句不但改变了s所占的一个字节，还把和s相临的高地址方向的三个字节也改变了。这三个字节是干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应用，这三个字节的值被改变了！这会造成崩溃性的错误。
　　让我们再来看一例：
　　例十八：
　　1、chara;
　　2、int*ptr=&a;
　　...
　　...
　　3、ptr++;
　　4、*ptr=115;
　　该例子完全可以通过编译，并能执行。但是看到没有？第3句对指针ptr进行自加1运算后，ptr指向了和整形变量a相邻的高地址方向的一块存储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是一条代码。而第4句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针时，程序员心里必须非常清楚：我的指针究竟指向了哪里。在用指针访问数组的时候，也要注意不要超出数组的低端和高端界限，否则也会造成类似的错误。
　　在指针的强制类型转换：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的类型)大于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是不安全的。至于为什么，读者结合例十七来想一想，应该会明白的。

http://embedfans.com/C/2007181016375897.htm

    经常会遇到关于二叉树的算法问题，虽然比较简单，不过我觉得还是有必要总结一下．顺便写了个sample程序，以供参考．本文中主要讨论关于二叉树的以下3个问题,都是用递归来实现，Divide and conquer也就是所谓的分冶策略．
    1.二叉树的高度
    2.二叉树的宽度
    3.比较两个二叉树是否相等
此文对应的参考程序可以在 http://shaohui.zheng.googlepages.com/bst.c 下载。

数据结构的定义

    先定义一个简单的二叉树，由于只是演示，所以定义得比较简单．

 1 #include <stdio.h>
 2
 3 #define MAX(x,y) ((x)>(y)?(x):(y))
 4
 5 //define a binary search tree
 6 typedef struct BNode
 7 {
 8     int val;
 9     struct BNode *left, *right;
10 }BNode,*BTree;

二叉树节点的值为val,另外为了比较方便还定义了一个宏MAX.

12 // insert a node to binary tree
13 // we assume that no duplicated elements
14 void BTreeInsert(BTree *bt, int val)
15 {
16     BNode *p = *bt,*cur = *bt;//p is a parent node of cur
17     while (cur != NULL)
18     {//find the position to insert node val
19         p = cur;
20         if ( val < cur->val )
21             cur = cur->left;
22         else
23             cur = cur->right;
24     }
25     BNode *n = malloc(sizeof(BNode));
26     n->val = val;
27     n->left = n->right = NULL;
28     if (p == NULL)
29         *bt = n;// the tree is empty
30     else
31     {
32         if (val < p->val)
33             p->left = n;
34         else
35             p->right = n;
36     }
37 } //BTreeInsert
还定义了一个函数BTreeInsert用来帮助创建二叉树．

二叉树的高度

基本方法：二叉树，分别求出左右子数的高度，然后取左右子树高度的最大数值，再加上１，就是二叉树的高度．
由于该问题又被划分为两个性质一样的子问题，因此很容易导致递归．
39 //get the depth of a BST
40 int BTreeDepth(BTree bt)
41 {
42     if (bt != NULL)
43     {
44         int dep_left = BTreeDepth(bt->left);
45         int dep_right = BTreeDepth(bt->right);
46         return MAX(dep_left,dep_right)+1;
47     }
48     return0;
49 } //BTreeDepth

二叉树的宽度

基本方法：左右子树的宽度相加，于是就得到二叉树的宽度．
66 //get the width of a BST
67 int BTreeWidth(BTree bt)
68 {
69     if (bt != NULL)
70     {
71         if ((bt->left == bt->right) && (bt->left == NULL))
72             return1;// bt is a leaf
73         else
74             return BTreeWidth(bt->left) + BTreeWidth(bt->right);
75     }
76     else
77         return0;
78 }//BTreeWidth
79

二叉树的比较

    如果我们认为左右子树位置很重要，也就是说把左右子树交换以后，我们认为它和原来的子树不一样了，那么只需要比较一次就可以了。
51 //compare 2 binary tree, if bt1 is equal bt2
52 //return 1, or return 0
53 int BTreeCompare(BTree bt1, BTree bt2)
54 {
55     if ((bt1==bt2) && (bt1==NULL)) // both bt1 and bt2 are empty
56         return1;
57     elseif ((bt1 != NULL) && (bt2 != NULL)) // none of bt1 and bt2 is empty
58     {
59         return BTreeCompare(bt1->left, bt2->left)
60             && BTreeCompare(bt1->right, bt2->right);
61     }
62     else// one of bt1 and bt2 is empty
63         return0;
64 }
    如果我们认为左右子树位置不重要，也就是说把左右子树交换以后，我们认为它和原来的子树还是一样的，那么我们还好多加判断．把其中一个子树左右位置交换以后再比较．那么原来的程序需要有一些改动．

59-60行需要改成以下内容就可以了。
59         return (BTreeCompare(bt1->left, bt2->left) && BTreeCompare(bt1->right, bt2->right))
60             || (BTreeCompare(bt1->left, bt2->right) && BTreeCompare(bt1->right, bt2->left));

长尾理论通常使用左边这张长尾曲线图来解释，头部是大热门，流行度曲线陡然下坠，但一直没有到零点。这个长长尾巴的价值就是长尾理论通篇讲述的核心。

《长尾理论》书中第110页中讲到“长尾就是一种幂率(power-law)曲线”，学过中学数学的都知道，幂率曲线就是类似f(x)=c/x的曲线，其中c为常量。大家看看确实和Chris Anderson描述的长尾曲线一模一样。

有了这个前提，我们来看看长尾理论是否真的彻底颠覆了二八法则？首先，了解一下“二八法则”，“二八法则”又称“帕累托法则”，是意大利经济学家帕累托在19世纪末发现的经济规律，他发现在经济活动中，少数群体显得更为重要，比如：20%的人口掌握80%的财富、20%的产品产生80%的销售额等等。因此这个法则也称为“重要少数法则”。

我们在任何一个地方截断长尾，比如x=5n的地方，这时候20%多数是x=n之前的部分。2个部分的总量分别是：

总量 = c+c/2+c/3+c/4+...+c/5n
头部 = c+c/2+c/3+c/4+...+c/n

1+1/2+1/3+1/4+...+1/n = ln(n+1)+r

头部/总量 = (ln(n)+r) / (ln(5n)+r) = (ln(n)+r) / (ln(n)+ln5+r)

其实Chris Anderson也承认：“真正的80/20法则只是承认帕累托分布的有效性，承认某些东西卖得远比其他东西要好，这在长尾市场和传统市场中都是成立的。”所以，长尾理论彻底颠覆了二八法则是没有根据的。

长尾理论不是颠覆性的概念，更多地是指导我们在丰饶经济的条件下，寻找合适的长尾市场，开拓新的销售渠道。所以Chris Anderson也重点谈到“即使有二八法则的统治，在丰饶经济环境下，我们也没有理由不去经营其它的80%产品”。或许，这就是对长尾理论最深刻的注解。

数学小知识：欧拉常数的由来

对于今天我们称为调和级数的

1+1/2+1/3+1/4+...

1+1/2+1/3+1/4+1/5+1/6+1/7+1/8+...
1/2+1/2+(1/4+1/4)+(1/8+1/8+1/8+1/8)+...

随后很长一段时间，人们无法使用公式去逼近调合级数，直到无穷级数理论逐步成熟。1665年Newton(牛顿)在他的著名著作《流数法》中推导出第一个幂级数：

ln(1+x) = x - x²/2 + x³/3 - ...

Euler(欧拉)在1734年，利用Newton的成果，首先获得了调和级数有限多项和的值。结果是：

1+1/2+1/3+1/4+...+1/n = ln(n)+r (r为常量)

他的证明是这样的：
根据Newton的幂级数有：

ln(1+1/x) = 1/x - 1/2x² + 1/3x³ - ...

1/x = ln((x+1)/x) + 1/2x² - 1/3x³ + ...

1/1 = ln(2) + 1/2 - 1/3 + 1/4 -1/5 + ...
1/2 = ln(3/2) + 1/2*4 - 1/3*8 + 1/4*16 - ...
......
1/n = ln((n+1)/n) + 1/2n² - 1/3n³ + ...

1+1/2+1/3+1/4+...1/n = ln(n+1) + 1/2*(1+1/4+1/9+...+1/n²) - 1/3*(1+1/8+1/27+...+1/n³) + ......

1+1/2+1/3+1/4+...1/n = ln(n+1) + r

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1416659

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1413933

　　SNS的技术起源:在互联网中，PC机、智能手机都没有强大的计算及带宽资源，它们依赖网站服务器，才能浏览发布信息。如果将每个设备的计算及带宽资源进行重新分配与共享，这些设备就有可能具备比那些服务器更为强大的能力。这就是分布计算理论诞生的根源，是SNS技术诞生的理论基础。

　　SNS的商业空间:当普通人通过安装SNS软件都可以拥有媲美网站服务器的计算及通信资源时，那些投资了大量服务器的互联网公司将怎么办呢?他们的优势在什么地方?会不会有更多的新型的互联网公司出现，而且他们的后台他们的前端有没有可能完全不是现在的GOOGLE、EBAY、新浪模式呢?甚至包括盛大网络游戏这样的运营商，他们引为骄傲的强大的3万台服务器集群，是不是他们的核心竞争力呢?当一个漫画作者家里的那台机器，就可以让他通过SNS视频器播放他的作品，他还需要去管理一个网站吗?或许一个家庭主妇不需要懂得HTML编程，不需要懂得网站这个词汇，只通过SNS菜谱发布程序及一台厨房里的PC就能让千百万人掌握她的手艺，而且她在厨房的灶台上的一招一式都清晰可见。这个时候，您会想到什么?

　　现在的互联网中，作为客户端的我们就像个蠢蛋，只能通过服务器才能干些奴隶般的事情，看别人的网站，玩别人的游戏，发发邮件，除此之外，我们没有自由。现在是开始革命的时候了!革命中心任务就是:如何让10多亿台电脑发挥他们自己的作用，让用户去创造和控制自己的信息。中间不需要公司的服务器来摆布我们。

 
         （解二：）
         SNS: Social Network Sofwaret，社会性网络软件。依据六度关系理论，以认识朋友的朋友为基础，扩展自己的人脉。并且无限扩张自己的人脉，在需要的时候，可以随时获取一点，得到该人脉的帮助。

         从2003年3月起，SNS网站悄然从美国兴起,短短的五个月内SNS就风靡整个北美地区。 据统计，在硅谷工作的三人中就有一个人使用SNS来拓展自己的交际圈。 SNS网站也受到了风险投资的追捧，有些SNS网站也获得了巨额的投资。

         在国内，这股旋风也吹得正猛，提供SNS服务的网站如雨后春笋般破土而出。 而SNS之所以走俏是人们对网络应用需求变化驱动使然。 随着网络社会化应用的发展，网民对网络的要求越来越高，不再仅仅局限于娱乐等方面，更希望网络能对工作、个人的发展提供更加便捷、高效的支撑和帮助。

         SNS的中文含义是“社交网络”。顾名思义，它就是社交关系的网络化。将我们现实中的社会圈子搬到网络上，根据不同的条件建立属于自己的社交圈子。 通过朋友认识朋友的形式，迅速建立起一个自己的基于信任的朋友圈子。在这个圈子里，相互之间具有较高的诚信度，区别于第一代交友模式的满无目的性。

         SNS可称为“第二代交友模式”。在这种模式下，结交的都是相对可靠的朋友，由于用户可以搜索的对象都是起朋友的朋友，因而从诚信和安全的角度上来看，它给了用户更大的信心和保障。此外，在SN中，不经朋友介绍和用户确认，用户的个人资料是不能被陌生人看到的。因此，对个人的隐私的保障性增强了。

　　用Adobe Reader打开想转换的PDF文件，接下来选择“文件→打印”菜单，在打开的“打印”窗口中将“打印机”栏中的名称设置为“Microsoft Office Document Image Writer”，确认后将该PDF文件输出为MDI格式的虚拟打印文件。

　　注:如果没有找到“Microsoft Office Document Image Writer”项，使用Office 2003安装光盘中的“添加/删除组件”更新安装该组件，选中“Office 工具 Microsoft DRAW转换器”。

　　然后，运行“Microsoft Office Document Imaging”，并利用它来打开刚才保存的MDI文件，选择“工具→将文本发送到Word”菜单，在弹出的窗口中选中“在输出时保持图片版式不变”，确认后系统会提示“必须在执行此操作前重新运行OCR。这可能需要一些时间”，不管它，确认即可。

　　注:对PDF转DOC的识别率不是特别完美，转换后会丢失原来的排版格式，所以转换后还需要手工对其进行排版和校对工作。

　　以上仅在word2003中可用，其他版本没有Microsoft Office Document Image Writer。

                                                                      攻无不克的PDF转Word

论坛中谈到很多PDF转换Word的方法，但有些PDF文档本身的制作过程中并不是以文字方式进行制作的，因而利用该方法仍不能进行转换。这里通过利用文字识别软件的功能进行“曲线转换”。
    软件需要：Adobe Acrobat Pro(注不是Reader)，识别软件(如汉王文本等)，Word

    方法：
    Step 1
    用Adobe Acrobat Pro打开该PDF文档
    点击File—Save As
    在弹出窗口中保存类型选取“Jpeg”

    Step 2
    打开Word程序，并新建一空白文件备用

    Step 3
    打开OCR程序，打开刚保存的Jpeg文档
    点击“版面分析”
    点击“文字识别”
    可在编辑窗口中进行更正编辑
    点击“插入Word文档”

    Step 4
    转到Word中，进行稍微的排版
    即可

    Step 1 转换为Jpeg文档的操作( Gif动画 )

    另：
     1.如果论文写作时需要大量引用部分图书，利用数码相机拍摄相关页面，放入OCR中一样可以识别转换成Word文档，这对没有扫描仪的我们相当有用

    2.其它诸如”ScanSoft PDF Converter for Microsoft Word v1.0“、”PDF2DOC“对某些PDF文档并不能识别与转换

    3.注意：此方法仅是”曲线转换“，如觉麻烦，请告知更好方法

    Step 2-3  Jpeg文档识别与Word文档l转换(省略Step 3 中“更正编辑“)
    Step 4 略

在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。

还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。

另外方面，Singleton也能够被无状态化。提供工具性质的功能，

Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。

如何使用?
一般Singleton模式通常有几种形式:

第二种形式:

使用Singleton.getInstance()可以访问单态类。

上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者进一步研究。

一般认为第一种形式要更加安全些。

使用Singleton注意事项：
有时在某些情况下，使用Singleton并不能达到Singleton的目的，如有多个Singleton对象同时被不同的类装入器装载；在EJB这样的分布式系统中使用也要注意这种情况，因为EJB是跨服务器，跨JVM的。

我们以SUN公司的宠物店源码(Pet Store 1.3.1)的ServiceLocator为例稍微分析一下：

在Pet Store中ServiceLocator有两种，一个是EJB目录下；一个是WEB目录下，我们检查这两个ServiceLocator会发现内容差不多，都是提供EJB的查询定位服务，可是为什么要分开呢？仔细研究对这两种ServiceLocator才发现区别：在WEB中的ServiceLocator的采取Singleton模式，ServiceLocator属于资源定位，理所当然应该使用Singleton模式。但是在EJB中，Singleton模式已经失去作用，所以ServiceLocator才分成两种，一种面向WEB服务的，一种是面向EJB服务的。

Singleton模式看起来简单，使用方法也很方便，但是真正用好，是非常不容易，需要对Java的类 线程 内存等概念有相当的了解。

总之：如果你的应用基于容器，那么Singleton模式少用或者不用，可以使用相关替代技术。

进一步深入可参考：

Double-checked locking and the Singleton pattern

When is a singleton not a singleton?

2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num is null
可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：
select id from t where num=0

3.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。

4.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num=10 or num=20
可以这样查询：
select id from t where num=10
union all
select id from t where num=20

5.in 和 not in 也要慎用，否则会导致全表扫描，如：
select id from t where num in(1,2,3)
对于连续的数值，能用 between 就不要用 in 了：
select id from t where num between 1 and 3

6.下面的查询也将导致全表扫描：
select id from t where name like '%abc%'
若要提高效率，可以考虑全文检索。

7.如果在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：
select id from t where num=@num
可以改为强制查询使用索引：
select id from t with(index(索引名)) where num=@num

8.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：
select id from t where num/2=100
应改为:
select id from t where num=100*2

9.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：
select id from t where substring(name,1,3)='abc'--name以abc开头的id
select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id
应改为:
select id from t where name like 'abc%'
select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'

10.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

11.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

12.不要写一些没有意义的查询，如需要生成一个空表结构：
select col1,col2 into #t from t where 1=0
这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样：
create table #t(...)

13.很多时候用 exists 代替 in 是一个好的选择：
select num from a where num in(select num from b)
用下面的语句替换：
select num from a where exists(select 1 from b where num=a.num)

14.并不是所有索引对查询都有效，SQL是根据表中数据来进行查询优化的，当索引列有大量数据重复时，SQL查询可能不会去利用索引，如一表中有字段sex，male、female几乎各一半，那么即使在sex上建了索引也对查询效率起不了作用。

15.索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有必要。

16.应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。

17.尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

18.尽可能的使用 varchar/nvarchar 代替 char/nchar ，因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。

19.任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

20.尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

21.避免频繁创建和删除临时表，以减少系统表资源的消耗。

22.临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。

23.在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

24.如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。

25.尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。

26.使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。

27.与临时表一样，游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。

28.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。

29.尽量避免大事务操作，提高系统并发能力。

30.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。

具体的SQL语句在很多情况下需要结合实际的应用情况来写，这里不作叙述。

花费更多的时间在前期的设计上，并通过团队过程来完成。在某种程度上，XP采用协作设计会议的方式-在团队开始编写产品代码时，大多数关键的设计决策已经完成。
书面文档也能减少对结对编程和团队同在一地的需求。