在程序使用Dll有两个加载方式，一种是动态方式，就是LoadLibrary载入Dll,然后用GetProcAddress来加载需要使用的Dll函数。另一种就是静态连接方式，将dll生成的lib，加入到工程中，然后就可以很方便的调用。

我们知道很多dll在发布时不提供lib，没有lib我们就不能静态的加载，所以得想办法来生成一个lib，在vs2005中有这样的一个命令

不过我们还需要一个def文件，怎样来获得一个def文件哪？

我们知道def是一个库导出文件 简单的格式是：EXPORTS  和 一些导出函数

我们可以用vc6自带的一个depends来查看dll中有哪些导出函数，来手动做一个.def文件

将xxx.dll和xxx.def，放到一个文件夹中，启动“Visual Studio 2005 命令提示”

将工作目录切换到放有xxx.dll和xxx.def的文件夹中输入：

这样将会产生一个xxx.lib了，将此lib文件和dll文件拷到工程中，就可以进行静态链接了

输出结果：
after initialization:
 p: 42
 q: NULL
after assigning auto pointers:
 p: NULL
 q: 42
after change and reassingnment:
 p: 55
 q: NULL
请按任意键继续. . .

编程语言

除了C++之外，还有Java、BASIC、COBOL、FORTRAN、PASCAL和C（只是因为它是B语言的后续语言）等编程语言。
所有这些称为高级语言，因为它们可以比较容易地表达出要计算机完成的工作，而且不针对某台计算机。
高级语言中的每个源语句一般映射为几个内部机器指令。
低级语言比较接近内部机器指令，通常称为汇编语言，一个汇编语言专门用于一种硬件设计，一般一个汇编指令映射为一个内部机器指令。

编程语言简史
FORTRAN是第一种开发出来的高级语言，第一个FORTRAN编译器是在19世纪50年代后期开发出来的。
已有40多年的历史了，目前仍广泛应用于科学和工程计算中，但C++和其他语言也逐渐进入这些领域。

COBOL语言专门用于商务数据处理应用程序，它的历史几乎与FORTRAN语言一样长，目前几乎不用COBOL编写代码。

BASIC在19世纪70年代诞生，那时已经有了个人计算机的概念。有趣的是，Microsoft销售的第一个产品是一个BASIC解释程序。
这种语言所固有的易用性使之很快普及，直到今天仍非常流行。

Java是在19世纪90年代开发的，它最初开发为Oak语言，用于给小型电子设备编程。
1995年，Oak演变为Java语言，可以在Web页面中内嵌代码，从那时起直到现在，这已经成为Java的主要用途。
Java成功的主要原因是它的可移植性。Java程序可以在任何支持它的硬件平台上运行，而且不需要任何修改。
Java语言的语法有许多特性，使它看起来很像C++，但有很大的区别。Java在可移植性方面比C++好，但执行性能比不上C++。

C在上个世纪70年代被开发为一种高级语言，用于低级编程，例如实现操作系统。大多数Unix操作系统就是用C编写的。

C++是19世纪80年代早期开发的，是一种基于C的面向对象语言。
顾名思义，C++表示C的累加。
由于C++基于C，所以这两种语言有许多共同的语法和功能，C中所有低级编程的功能都在C++中保留下来。
但是，C++比其前身丰富得多，用途也广泛得多。
C++对内存管理功能进行了非常大的改进，C++还具有面向对象的功能，所以C在功能上只是C++的一个很小的子集。
C++在适用范围、性能和功能上也是无可匹敌的。
因此，目前大多数高性能的应用程序和系统仍使用C++编写。

解释性程序和编译性程序的执行过程
无论使用哪种编程语言，编写出来的程序都是由各个指令或源语句构成的，它们描述了希望计算机执行的动作。
这些指令或源语句统称为源代码，存储在磁盘的源文件中。
任何规模的C++程序都是由若干个源文件组成的。

编程语言的目的是，与计算机可以执行的程序相比，能够更简单地描述希望计算机执行的动作。
计算机只能执行包含机器指令（也称为机器代码）的程序，不能直接执行我们编写的程序。

用前面提到的语言编写的程序基本上有两种执行方式，在大多数情况下，一种语言会选择其中一种执行方式。
例如，用BASIC语言编写的程序通常是解释性的，
也就是说，另一个称为解释器的程序会检查BASIC源代码，确定该程序要做什么，再让计算机完成这些动作。

而C++是一种编译语言。在执行C++程序之前，必须用另一个程序（即编译器）把它转换为机器语言。
编译器会检查并分析C++程序，并生成机器指令，以执行源代码指定的动作。
当然，解释和编译都不像这里描述的那样简单，但其工作原理就是这样。

使用解释性语言，执行过程是间接的，也就是说，每次执行程序时，都需要确定源代码的意图。
因此，这种语言比编译语言的对应程序的执行速度慢得多，有时要慢100倍。
其优点是在运行之前，不必等待程序的编译。
使用解释性语言，一旦输入代码，就可以立刻执行程序。

任何一种语言要么是解释性，要么是编译性的，这通常是由该语言的设计和用途来决定。
前面说过BASIC是一种解释性语言，但这不是绝对的，目前有许多BASIC语言的编译器。

没有所谓“最好”的语言，因为这取决于环境。
看具体环境在意的是开发速度，还是运行速度，又或是移植能力等等。

库
每次编写程序时，如果总是要从头开始编写，就相当繁琐。
为了解决这个问题，编程语言通常提供了大量预先编写好的代码，以执行标准的操作，这样就不必重新编写这些代码了。
可用于任意程序的标准代码都保存在一个库中。
编程语言附带的库跟语言本身一样重要，因为库的质量和使用范围对完成某一编程任务所需的时间有非常大的影响。

C++是一种功能强大的语言

C++的ANSI/ISO标准

名称
C++程序中的许多元素都有用来表示它们的名称，也称为标识符。
在C++程序中，可以命名的5种元素是：
函数、变量、类型、标签、命名空间

关键字
C++中有一些保留字，称为关键字，它们在C++语言中有特殊的含义。

C++语句和语句块
语句是指定程序做什么和程序所处理的数据元素的基本单元。

把名称引入源文件的语句称为声明。
声明只是引入名称，指定该名称表示什么，它与定义不同。

定义是分配一些内存，来包含名称所指代的内容。
大多数声明也是定义??????????(这句如何理解？？)

变量是内存中一个可以存储数据项的空间。
下面的语句示例声明了一个变量名，定义并初始化了一个变量：
double result = 0.0;
这个语句把名称result声明为一个double类型的变量（声明），
把内存分配给该变量（定义），
并设置其初始值为0.0（初始化）。

可以把几个语句放在一对花括号中，此时这些语句就称为语句块。
函数体就是一个语句块。
语句块也称为复合语句，因为在许多情况下，语句块可以看做是一个语句。

在C++中，在可以放置一个语句的任何地方，都可以放置一个包含在花括号对中的语句块。

语句块可以放在其他语句块内部，这个概念称为嵌套。语句块可以嵌套任意级。

语句块对用于存储数据项的变量有重要的作用。（变量作用域?）

代码的显示样式
注意使用制表符、空格缩进程序语句，显示出这些语句的逻辑；再以一致的方式使用定义程序块的匹配花括号，使块之间的关系更清晰。

程序结构
每个C++程序都由一个或多个文件组成。
根据约定，用于存储源代码的文件有两类：头文件和源文件。
头文件可以包含描述程序所需的数据类型的代码，以及其他类型的声明。
头文件通常用文件扩展名.h来区分，但这不是强制的。
源文件的扩展名是.cpp，它包含了函数声明，即程序的可执行代码。这些代码通常引用在自己的头文件中定义的数据类型的声明或定义。

编译器在编译代码时，需要知道这些声明或定义，因此应在文件的开头通过#include指令指定.cpp文件中需要的.h文件。
#include指令是编译器的一个指令，它可以把指定头文件的内容插入代码，还需要为代码需要的标准库头文件添加#include指令。

编译器提供了大量的标准头文件，其中包含使用标准库功能所需要的声明。
实际上，C++的标准头文件名都没有扩展名，这就把它们与其他头文件区分开来。

程序的函数和执行
C++程序至少包含一个函数main()，但程序一般还包含许多其他函数，一些是自己编写的，另一些是标准库函数。
执行一个函数称为调用函数。在调用函数时，可以给它传送数据项。
在函数执行完后，执行控制返回到调用函数的地方。
函数在执行完毕时，还可以把一个值返回到调用的位置上。
返回值可以存储起来，以备以后使用，也可以参与某种类型的计算，例如算术表达式的计算。

从源文件中创建可执行文件
从C++源代码中创建可以执行的程序模块需要两步：
第一步是编译器把每个.cpp文件转换为对象文件，其中包含了与源文件内容对应的机器码。
第二步是链接程序把编译器生成的对象文件合并到包含完整可执行程序的文件中。

编译器把每个源文件看作一个独立的实体，为每个.cpp文件生成一个对象文件。
然后在链接步骤中，把程序的对象文件和必要的库函数组合到一个可执行文件中。

实际上，编译是一个迭代的过程，编写源码，编译，发现错误，修改源码，再编译，发现错误，再修改，再编译，……

编译
源文件的编译过程包含两个主要阶段，而它们之间的转换是自动的。
第一个阶段是预处理阶段，在正式的编译阶段之前进行。
预处理阶段将根据已放置在文件中的预处理指令来修改源文件的内容。
#include指令就是一个预处理指令，它把头文件的内容添加到.cpp文件中。还有其他许多预处理指令。

这个在编译之前修改源文件的方式提供了很大的灵活性，以适应不同的计算机和操作系统环境。
一个环境需要的代码跟另一个环境所需的代码可能有所不同，因为可用的硬件或操作系统是不同的。
在许多情况下，可以把用于不同环境的代码放在同一个文件中，再在预处理阶段修改代码，使之适应当前的环境。

预处理器一般不能独立于编译器来执行，调用编译器会自动执行预处理过程，之后才编译代码。

链接
编译器为给定源文件输出的是机器码，执行这个过程需要较长时间。
在对象文件之间并没有建立任何连接。
对应于某个源文件的对象文件包含在其他源文件中的定义的函数引用或其他指定项的引用，而这些函数或项仍没有被解析。
同样，也没有建立同库函数的链接。
实际上，这些函数的代码并不是文件的一部分。
这些工作是由链接程序完成的。

链接程序把所有对象文件中的机器码组合在一起，
并解析它们之间的交叉引用。
它还集成了对象模块所使用的库函数的代码。
这是链接程序的一种简化表示，因为这里假定在可执行模块中，模块之间的所有链接都是静态建立的。
实际上有些链接是动态的，即这些链接是在程序执行时建立的。

链接程序静态地建立函数之间的链接，即在程序执行之前建立组成程序的源文件中所包含的函数链接。
动态建立的函数之间的链接（在程序执行过程中建立的链接）将函数编译并链接起来，创建另一种可执行模块——动态链接库或共享库。
动态链接库中的函数链接是程序调用函数时才建立的，在程序调用之前，该链接是不存在的。

动态链接库优点：
动态链接库中的函数可以在几个并行执行的程序之间共享，在执行的多个函数需要动态链接库中的函数所提供的服务时，这将节省同一个函数占用的内存空间。
动态链接库在调用其中的函数之前是不会加载到内存中的，也就是说，如果不使用给定动态链接库中的函数，该动态链接库就不会占用内存空间。

动态链接库是与操作系统紧密相关的一个系统功能。

C++源字符
编写C++语句要使用基本源字符集，这些是在C++源文件中可以显式使用的字符集。
包括：大小写字母，数字，控制字符，一些特殊字符。

在C++中使用的字符定义并没有说明字符的编码方式。编译器将决定用于编写C++源代码的字符在计算机上如何表示。

通用字符集（Universal Character Set, UCS）。
由UCS标准定义的字符编码与Unicode定义的编码相同。

三字符序列
就是用于表示另一个字符的三个字符序列。以前为了表示键盘上没有的字符，这是必不可少的一种方法。
编译器会用对应的字符替代它们，再对源代码进行其他处理。

转义序列
通过转义序列可以把控制字符输入字符常量。转义序列是指定字符的一种间接方式，通常以一个反斜杠\开头。

由于反斜框表示转义序列的开始，因此把反斜杠字符输入一个字符常量的唯一方式是使用两个连续的反斜杠。

转义序列还提供了用键盘不支持的语言来表示字符的一种通用方式，因为可以使用十六进制（基数是16）或八进制（基数是8）数字前置一个反斜杠来指定字符的编码。

由于使用了数字编码，可以用这种方式指定任何字符。

在C++中，十六进制数据以x或X开头。

还可以使用至多3个八进制数字前置一个反斜杠来表示字符。例如\165。没有x或X，就表示该编码应解释为一个八进制数字。

cout << "\n\" Least said\n\t\tsoonest mended.\ "\n\a";
双引号之间的字符串称为字符串字面量。
双引号字符表示该字符串字面量的开始和结束，它们不是字符串的一部分。

字符串内部的双引号不会解释为字符串字面量的结束，这是因为每个双引号的前面都有一个反斜杠，表示这是一个转义序列。

语句中的空白
除了在语句的元素之间或引号中的字符串内用作分隔符之外，编译器会忽略空白。
因此可以在代码中包含任意多个空白，使程序的可读性更高。

在一些编程语言中，语句的结尾是代码行的末尾，但在C++中，语句的结尾用分号表示。
因此，可以把一个语句分散放在好几行代码行上。

程序的注释
C++中注释有两种形式：单行和多行。
单行注释以双斜杠开头（//）。
编译器会忽略双斜杠后面的所有内容。

多行注释以/*开头，以*/结尾。在/*和*/之间的所有内容都被忽略。
注意多行注释不能嵌套，否则会使编译器发出错误消息。

标准库
标准库包含了大量的函数和其他支持实体，增加和扩展了C++的基本语言功能。
标准库的内容是C++的一部分，在语言的语法和语义方面跟C++相同。
C++的标准定义了这两者，所以每个符合该标准的编译器都提供了完整的标准库。

标准库的范围是很特殊的。
使用该标准库将获得非常多的功能，包括基本元素如基本语言支持、
输入输出函数和异常处理（异常是在程序执行中发生的偶然事件，常常是某种错误）、
实用函数，数学例程和各种预先编写好并测试通过的功能。
在程序执行过程中可借助这些功能来存储和管理数据。

使用标准库所需要的定义和声明位于标准头文件中。
C++标准库中的几乎所有内容都是在命名空间std中定义的。

用C++编程

过程化编程方法和面向对象编程方法

小结
C++程序至少包含一个main()函数。
函数的可执行部分由包含在一对花括号中的语句组成。
一对花括号定义了一个语句块。
在C++中，语句用分号结束。
关键字是C++中有特殊含义的一组保留字。程序中的实体不能与C++语言中的任何关键字同名。
C++程序包含在一个或多个文件中。
定义函数的代码通常存储在扩展名为.cpp的文件中。
定义数据类型的代码通常存储在扩展名为.h的头文件中。
C++标准库提供了支持和扩展C++语言的大量功能。
C++中的输入和输出是利用流来执行的，并且需要使用插入和撮运算符，即<<和>>。
面向对象的编程方式需要定义专门用于某程序的新数据类型。一旦定义好需要的数据类型，就可以根据这些新数据类型来编写程序。

举例说明，我们要写一个test.exe文件，生成最后的可执行文件有4个步骤：

1，编译源文件x.cpp，其中用到头文件common.h，它们经编译器编译成x.obj；

2，编译源文件y.cpp，其中用到头文件common.h和y.h，它们经编译器编译成y.obj；

3，资源脚本文件x.rc，经过资源编译器编译成x.res；

4，最后用链接器将x.obj，y.obj和x.res链接成test.exe。

可以看出，当程序调试的时候，如果修改了x.cpp，也就是说x.obj的文件时间比x.cpp要早，就需要重新进行步骤1和4；如果修改了y.cpp或y.h，那么需要重新执行步骤2和4；如果修改的是x.rc，则步骤3和4必须重新执行；如果同时修改了common.h和x.rc，那么必须重复全部步骤。在这个例子中，文件的依赖关系就是：

1，test.exe依赖于x.obj，y.obj和x.res；

2，x.res依赖于x.rc；

3，x.obj依赖于x.cpp和common.h；

4，y.obj依赖于y.cpp，common.h和y.h。

make可以根据文件的时间正确判断文件的新旧并执行相应的步骤。但make又是如何知道文件之间的依赖关系呢？这需要用户用一个描述文件来指定。这个描述文件就叫做makefile，执行make工具的时候，它会默认用makefile做描述文件名来进行相应的工作，书写描述文件有规定的语法，虽然语法不是很简单，但写好以后就省事多了。

Microsoft的make工具文件名为nmake.exe，Borland公司的make工具文件名是make.exe。

两者默认的描述文件名都是makefile，描述文件的语法也大同小异，只是使用时命令行参数有些不同。

nmake的用法

在命令行键入namke/? 可以显示帮助信息，nmake的语法为：

       nmake [选项] [/f 描述文件名] [/x 输出信息文件名] [宏定义] [目标]

说明如下：

/f ：如果描述文件名不使用默认的“makefile”，可以用/f参数指定。

/x ：如果想把屏幕输出的信息存到一个文件中，可以用/x 参数指定。（用DOS下的管道操作符 nmake > 文件名的方法无效）。

宏定义：可以用新的定义覆盖描述文件中的宏定义。

目标：可以指定建立描述文件中描述的某个文件，如上面的例子中默认是生成最后的test.exe文件，也可以用nmake x.res指定更新x.res文件。

nmake的常用选项：

/A           不检测文件更新时间，强制更新所有文件

/B           文件更新时间相等时也要更新文件

/D           make时显示文件新旧信息

/N           显示make时要执行的命令，但并不真正执行

/P           一个比较有用的选择，make时显示详细的信息

由于nmake的应用是基于文件时间的，当计算机的时钟不准确或文件拷贝到另一台计算机后文件时间有些偏差，那么可能文件的更新会不正确，这时最好用/A选项强制把所有文件更新一遍。在平时使用的时候，以makefile当做建立的描述文件名，那么仅键入不加参数的nmake命令就可以完成所有工件了。

描述文件的语法

make工具最主要也是最基本的功能就是通过描述文件来描述源程序之间的相互关系并自动维护编译工作，而描述文件需要按照某种语法进行编写，文件中需要说明如何编译各个源文件并链接生成可执行文件，并要求定义源文件之间的依赖关系，为了更方便使用，文件中同时可以用一些宏定义。描述文件一般需要包含以下内容：

l         注释

l         宏定义

l         显式规则

l         隐含规则

在这里，以上面的test.exe的例子写出一个描述文件，再逐步介绍各部分的书写语法。为了方便使用，一般都把描述文件的文件名取为默认文件名：makefile（无扩展名）。这个例子的makefile文件如下：

1、注释和换行

makefile中的注释是以#号开头一直到行尾的字符，当nmake工具处理到这些字符的时候，它会完全忽略#号及全部注释字符。

当一行的内容过长的时候，可以用换行符来继续，makefile的换行符是反斜杠\。

在使用换行符的时候要注意在反斜杠后面不能再加上其他字符，包括注释和空格，否则nmake检测到反斜杠不在一行的最后，就不会把它当成换行符解释，就会出现错误。

2、宏定义

makefile中允许使用简单的宏定义指代源文件及其相关编译信息，可以把宏称为变量，在整个描述文件中，只要符合下面语法的行就是宏定义：

       变量名=变量内容

如上面例子文件中的2到8行就是宏定义，在引用宏时只需在变量前加$符号，但是要注意的是，如果变量名的长度超过一个字符，在引用时就必须加圆括号()，下面都是有效的宏引用：

       $(LINK_FLAG)

       $(EXE)

       $A

       $(A)

其中最后两个引用是完全一致的。

宏定义的使用可以使makefile的使用更灵活：首先可以使文件便于修改，比如把第8行和第18行中ml的选项部分写成宏定义，以后要改变编译选项的时候，只要直接在makefile文件头部改变宏定义就可以了，不必重新阅读整个makefile文件；其次，当不止一个地方用到同一个文件的时候，把文件名定义为宏定义可以减少错误，增加可读性，同时也可以便于修改；最大的好处是可以直接在命令行中用新的定义覆盖，比如在命令行中键入：

       nmake ML_FLAG – “/c /coff /F1”

那么这时就会以新的/c /coff /F1定义代替makefile中定义的/c /coff，在这种使用中要注意两个问题，一是宏名称要区分大小写，ML_FLAG和ml_flag是不一样的；二是定义值中有空格的时候要用双引号引起来，没有空格时可以不用双引号，如ML_LAG=/c，这使临时使用不同的参数编译文件时可以不必修改makefile。

3、显式规则

makefile中包含有一些规则，这些规则定义了文件之间的依赖关系和产生命令，一个规则的格式是这样的：

       目标文件：依赖文件；命令              （方法1）

       或

       目标文件：依赖文件

                     命令                                   （方法2）

在规则定义和命令行中，不能包含注释，例子中的第11行和12行把宏定义展开后就是：

       Test.exe : x.obj y.obj x.res

                     Link /subsystem:windows /out: Test.exe x.obj y.obj x.res

这里的目标文件就是Test.exe，它依赖于3个文件x.obj，y.obj和x.res，如果有必要，产生目标文件的命令就是下面的Link命令，整个规则可以用两种方法，用第二种方法的时候，命令可以从第二行开始，第二行的分号“;”省略，但是这时命令前面必须有一个Tab字符，否则nmake无法区分这究竟是命令还是别的定义。目标文件可以有多个，依赖文件也可以有多个，同时命令也可以由多个命令行组成，当然这时候就必须用第二种方法定义了。

可以也可以用test.exe生成的规则定义其他文件，如x.obj或x.res的生成方法，但nmake如何知道哪个是最终要make的文件呢？实际上nmake默认将整个描述文件的第一条规则中目标文件认为是最终文件，如果我们把11，12行放到第13行后面，那x.obj和y.obj的建立规则就成了第一条规则，nmake建立了x.obj和y.obj之后就不理会test.exe的建立了，所以我们必须把最终需要生成的文件放在第一条规则定义。当然，在nmake的命令行参数中可以指定要make的目标，如我们要生成x.res文件，那么不必修改makefile将x.res的描述规则移动到最前面，而是直接在命令行键入以下命令即可：

       nmake x.res

参数中也可以同时带好几个目标文件名，nmake会一一处理，如果指定的目标文件没有对应的规则，nmake会返回一个出错信息：

       fatal error U1073: don’t know how to make ‘xxx 文件’

当用户要求nmake去建造一个目标时，make会去找到这个目标的依赖规则，这时第二行中的命令并不会立刻就执行，而是首先要做一些事情：nmake先去检查依赖文件是否是另一条规则的目标文件，如果是则先处理这一条规则，否则不是，nmake再检查各个依赖文件的时间，看这些文件有没有比目标文件更新的，如果没有，nmake会决定不再重新建造目标文件，并给出提示：“xxx 文件”is up-to-date，如果依赖文件有比目标文件更新的，才执行命令。

所以一个顺序下来，所有的目标文件以及它们的依赖文件，以信依赖文件的依赖文件都会被检查并更新，总而言之，一个目标文件的建立包含了顺序正确的指令链接，这个链接结构是树状的，目标文件是根，一级级扩展到多个文件，我们要求的是nmake去建立链接中处于根部的那个文件，nmake要根据链接结构从目标开始向初始状态前进，最后慢慢回来，在这个过程中执行建立每个文件所必须的命令，一直到最终目标建立完成。

目标也可以没有依赖文件，而目标也可以不是一个真正存在的文件，如例子第23行到第25行行中的clean是一个目标，但我们并不是要生成一个clean文件，而是希望在文件调试完毕后用nmake来清除临时文件，当我们键入nmake clean的时候，工作目录下并没有clean这个文件，那么nmake就会去执行clean定义中的命令，因为nmake把每一个不存在的目标当做是一个过时的目标，如此一来，就会删除中间过程中的文件*.obj和*.res。

指出了目标文件全名的规则称为显式规则，但有些类别的文件的编译方法可以是雷同的，如从asm文件产生obj文件的命令总是用ml，从rc文件产生res文件的命令总是用rc，对于每个文件都写一条规则有些多余，这时候就要用到隐含规则。

4、隐含规则

隐含规则可以为某一类的文件指定建立的命令，它具体定义了如何将带一个特定扩展名的文件转换成具有另一种扩展名的文件，定义的格式是：

       .源扩展名 .目标扩展名 ： ；命令          （方法1）

       或

       .源扩展名 .目标扩展名 ：

                     命令                                          （方法2）

隐含规则的语法和显式规则相似，也是用“：”隔开，在分号“；”后面书写命令，也可以不用分号“；”而将命令写在第二行，同理，这时命令之前要加一个Tab字符。

隐含规则不能有依赖文件，所以冒号“：”后面没有内容，例子中的第17、18行定义了从asm文件建立obj文件的隐含规则，第19和20行定义了从rc文件建立res文件的隐含规则，隐含规则中无法指定确定的输入文件名，因为输入文件名是泛指的有相同扩展名的一整类文件，这时候就要用到几个特殊的内定宏来指定文件名，这些宏是$@，$*，$?和$<，它们的含义如下：

       $@         全路径的目标文件。

       $*           除去扩展名的全路径的目标文件。

       $?           所有源文件名。

       $<          源文件名（只能用在隐含规则中）。

所以第19、20行中的rc $<用于x.rc的时候就是rc x.rc。

读者可能注意到一些显式规则没有命令行，如第13行的$(OBJS): Common.inc指出了所有的obj文件全部依赖于Common.inc文件，第14行的 y.obj:y.inc则指出了y.obj同时也依赖于y.inc和第13行的规则合并，y.obj依赖于Common.inc也依赖于y.inc，但是这两个条规则都没有指出产生这些obj文件的命令，所以nmake处理的时候会到隐含规则中去找命令行，最后会用第18行的ml $(ML_FLAG) $<命令去产生这些obj文件。

makefile关系到整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

makefile带来的好处就是——自动化编译，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。

不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章。

关于程序的编译和连接

在此，先说说关于程序编译的一些规范和方法，一般来说，无论是C、C++，还是pas，首先要把源文件编译成中间的代码文件，在Windows下也就是.obj文件，UNIX下是.o文件，即Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫做链接（link）。

编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。

链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ文件）来链接我们的应用程序。链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数的时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File），也就是.lib文件，在UNIX下，是Archive File，也就是.a文件。

总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成Object File。而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error）。在VC下，这种错误一般是：Link 2001错误，意思就是说，链接器未能找到函数的实现。你需要指定函数的Object File。

言归正传。

Makefile介绍

make命令执行时，需要一个Makefile文件，以告诉make命令要怎么样的去编译和链接程序。

Makefile规则：

规则包含两个部分，一个是依赖关系，一个是生成目标的方法。

target … : prerequisites…

command

…

…

目标：先决条件

命令

target也就是一个目标文件，可以是Object File，也可以是执行文件。还可以是一个标签（Label）。

prerequisites 就是，要生成那个target所需要的文件或目标。

command 也就是make需要执行的命令。（任意的Shell命令）

这是一个文件的依赖文件，也就是说，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。说白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。这就是Makefile的规则。也就是Makefile中最核心的内容。

在Makefile中，规则的顺序是很重要的，因为，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让make知道你的最终目标是什么。一般来说，定义在Makefile中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。

一个示例：一个工程只包含两个文件，一个汇编源码文件*.asm，一个资源文件.rc。注：这是我学习Win32汇编程序如果定义菜单的例子。

NAME = Menu

OBJS = $(NAME).obj

RES = $(NAME).res

LINK_FLAG = /subsystem:windows

ML_FLAG = /c /coff

$(NAME).exe: $(OBJS) $(RES)

       Link $(LINK_FLAG) $(OBJS) $(RES)

.asm.obj:

       ml $(ML_FLAG) $<

.rc.res:

       rc $<

clean:

       del *.obj

       del *.res

make是如何工作的

在默认的方式下，也就是我们只键入make命令。那么，

1，make会在当前目录下找名称为“Makefile”或“makefile”的文件。

2，如果找到，它会找文件中的每一个目标文件（target），并把这个文件作为最终的目标文件。比如是XXX，一般它是一个可执行文件。

3，如果这个XXX文件不存在，或是XXX所依赖的后面的文件YYY的修改时间要比XXX这个文件新，那么，他就会执行后面所定义的命令来生成XXX这个文件。

4，如果XXX所依赖的YYY文件存在，那么make会在当前文件中找目标为YYY文件的依赖性，如果找到则再根据那一个规则生成YYY文件。

5，当然，你的C文件和H文件都是存在的，于是make会生成YYY文件，然后再用YYY文件生成make的终极任务，也就是执行文件XXX了。

这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只管文件的依赖性，即，如果在我找到了依赖关系之后，冒号后面的文件还是不在，那么对不起，我就不工作啦。

通过上述分析，我们知道，像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，不过，我们可以显式让make执行。即命令——“make clean”，以此来清除所有的目标文件，以便重编译。

于是在我们编程中，如果这个工程已经被编译过了，当我们修改了其中一个源文件，比如file.c，那么根据我们的依赖性，我们的目标file.obj会被重编译（也就是在这个依赖性关系后面所定义的命令），于是file.obj的文件也是最新的啦，于file.obj的文件修改时间要比最终的可执行文件XXX要新，所以XXX也会被重新链接了。

makefile中使用变量

为了makefile的易维护，在makefile中我们可以使用变量。

makefile的变量也就是一个字符串，理解成C语言的宏可能会更好一些。

比如，我们声明一个变量，叫OBJS.

在makefile一开始就这样定义：

OBJS = 1.obj 2.obj 3.obj

于是，我们就可以很方便地在我们的makefile中以“$(OBJS)”的方式来使用这个变量了。

Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。

1、显式规则。显式规则说明了，如果生成一个或多个目标文件。这是由Makefile的书写者明显指出，要生的文件，文件的依赖文件，生成的命令。

2、隐晦规则。由于我们的make有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书写Makefile，这是由make所支持的。

3、变量的定义。在Makefile中我们要定义一系列的变量，变量一般都是字符串，这个有点像C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。

4、文件指示。其包括了三个部分，一个是在一个Makefile中引用另一个Makefile，就像C语言中的include一样；另一个是指根据某些尾部指定Makefile中的有效部分，就像C语言中的预编译#if一样；还有就是定义一个多行的命令。

5、注释。Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用“#”字符，这个就像C/C++中的“//”一样。如果你要在你的Makefile中使用“#”字符，可以用反斜杠进行转义，如：“\#”。

先就整理到这里，不敢再往下看了，内容太多了，先有个概念，以后遇到问题再看。

shareddata.h
// shareddata.h
// Definitions for Type enumeration and SharedData structure
#ifndef SHAREDDATA_H
#define SHAREDDATA_H
enum Type { Double, Float, Long, Int, pDouble, pFloat, pLong, pInt };

struct SharedData {
    union {          // An anonymous union
        double dData;
        float fData;
        long lData;
        int iData;
        double* pdData;  // Pointers to various types
        float* pfData;
        long* plData;
        int* piData;
    };
    Type type;            // Variable of the enumeration type Type
    void show();        // Display a SharedData value
};
#endif

shareddata.cpp
// shareddata.cpp
// SharedData function definition
#include "shareddata.h"
#include <iostream>
using std::cout;
using std::endl;

void SharedData::show() {
    switch (type) {
    case Double:
        cout << endl << "Double value is " << dData << endl;
        break;
    case Float:
        cout << endl << "Float value is " << fData << endl;
        break;
    case Long:
        cout << endl << "Long value is " << lData << endl;
        break;
    case Int:
        cout << endl << "Int value is " << iData << endl;
        break;

    case pDouble:
        cout << endl << "Pointer to double value is " << *pdData << endl;
        break;
    case pFloat:
        cout << endl << "Pointer to float value is " << *pfData << endl;
        break;
    case pLong:
        cout << endl << "Pointer to long value is " << *plData << endl;
        break;
    case pInt:
        cout << endl << "Pointer to int value is " << *piData << endl;
        break;
    default:
        cout << endl << "Error - Invalid Type" << endl;
        break;
    }
};

main.cpp
// main.cpp
// Exercisiong SharedData
#include "shareddata.h"
#include <iostream>
using std::cout;
using std::endl;

void main() {
    int number = 99;
    long lNumber = 9999999L;
    double value = 1.618;
    float pi = 3.1415f;

    SharedData shared = { 0.1 }; // Initially a double
    shared.show();

    // Now try all four pointers
    shared.piData = &number;
    shared.type = pInt;
    shared.show();

    shared.plData = &lNumber;
    shared.type = pLong;
    shared.show();

    shared.pdData = &value;
    shared.type = pDouble;
    shared.show();

    shared.pfData = &pi;
    shared.type = pFloat;
    shared.show();
}

输出结果：

Double value is 0.1

Pointer to int value is 99

Pointer to long value is 9999999

Pointer to double value is 1.618

Pointer to float value is 3.1415

//main.cpp

按照上面的格式就可以执行。如果把class A的函数max的实现从头文件中拿出来放在一个cpp文件中
，则会产生错误，代码如下：
//myHeader.h

//main.cpp

这时候就会出错，原因就是VC6不支持模板函数在cpp文件中的实现。解决的办法是把其实现放在头文件中，
不一定放在定义类的头文件中，可以放在独立的头文件中。
注意：其实根据实质，也可以把模板函数的实现放在cpp文件中，但是要把cpp文件包含在调用该模板函数的
文件中。
代码如下：
//myHeader.h

//main.cpp