[免费下载 c语言深度解剖[1]-第11章

按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！



3。4，#error预处理　
#error预处理指令的作用是，编译程序时，只要遇到　
#error就会生成一个编译错误提
示消息，并停止编译。其语法格式为：　


#error　
error…message

注意，宏串　
error…message不用双引号包围。遇到　
#error指令时，错误信息被显示，可能同时
还显示编译程序作者预先定义的其他内容。关于系统所支持的　
error…message信息，请查找
相关资料，这里不浪费篇幅来做讨论。


3。5，#line预处理　
#line的作用是改变当前行数和文件名称，它们是在编译程序中预先定义的标识符

命令的基本形式如下：　


#linenumber＇〃filename〃＇

其中＇＇内的文件名可以省略。

例如：　


#line30　
a。h

其中，文件名　
a。h可以省略不写。
这条指令可以改变当前的行号和文件名，例如上面的这条预处理指令就可以改变当前的行号
为　
30，文件名是　
a。h。初看起来似乎没有什么用，不过，他还是有点用的，那就是用在编译
器的编写中，我们知道编译器对　
C源码编译过程中会产生一些中间文件，通过这条指令，
可以保证文件名是固定的，不会被这些中间文件代替，有利于进行分析。

3。6，#pragma预处理
在所有的预处理指令中，#pragma指令可能是最复杂的了，它的作用是设定编译器的
状态或者是指示编译器完成一些特定的动作。#pragma指令对每个编译器给出了一个方法；
在保持与　
C和　
C＋＋语言完全兼容的情况下；给出主机或操作系统专有的特征。依据定义　
；编译
指示是机器或操作系统专有的；且对于每个编译器都是不同的。
其格式一般为：　


#pragma　
para
其中　
para为参数，下面来看一些常用的参数。

3。6。1，#pragma　
message　
message参数：Message参数是我最喜欢的一个参数，它能够在编译信息输出窗

口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为：　
#pragmamessage（“消息文本”）
当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。

当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有
正确的设置这些宏，此时我们可以用这条指令在编译的时候就进行检查。假设我们希望判
断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法　


#ifdef　
_X86　
#Pragma　
message（“_X86　
macroactivated！”）　
#endif
当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_　


X86　
macroactivated！”。我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了


。

3。6。2，#pragma　
code_seg
另一个使用得比较多的　
pragma参数是　
code_seg。格式如：　
#pragma　
code_seg（＇〃section…name〃＇；〃section…class〃＇＇）


它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。

3。6。3，#pragma　
once　
#pragma　
once（比较常用）
只要在头文件的最开始加入这条指令就能够保证头文件被编译一次，这条指令实际上在　
VisualC＋＋6。0中就已经有了，但是考虑到兼容性并没有太多的使用它。

3。6。4，#pragma　
hdrstop　
#pragma　
hdrstop表示预编译头文件到此为止，后面的头文件不进行预编译。BCB可以
预编译头文件以加快链接的速度，但如果所有头文件都进行预编译又可能占太多磁盘空间，
所以使用这个选项排除一些头文件。

有时单元之间有依赖关系，比如单元　
A依赖单元　
B，所以单元　
B要先于单元　
A编译。
你可以用#pragma　
startup指定编译优先级，如果使用了#pragma　
package（smart_init），BCB
就会根据优先级的大小先后编译。

3。6。5，#pragma　
resource　
#pragma　
resource〃*。dfm〃表示把*。dfm文件中的资源加入工程。*。dfm中包括窗体
外观的定义。

3。6。6，#pragma　
warning　
#pragma　
warning（　
disable：　
4507　
34；once：　
4385；error　
：　
164　
）

等价于：　


#pragma　
warning（disable：4507　
34）//不显示　
4507和　
34号警告信息　


#pragma　
warning（once：4385）　
//　
4385号警告信息仅报告一次　


#pragma　
warning（error：164）　
//把　
164号警告信息作为一个错误。

同时这个　
pragmawarning也支持如下格式：　


#pragma　
warning（push＇；n＇）　


#pragma　
warning（pop）

这里　
n代表一个警告等级（1…4）。　


#pragma　
warning（push）保存所有警告信息的现有的警告状态。　


#pragma　
warning（push；n）保存所有警告信息的现有的警告状态，并且把全局警告

等级设定为　
n。　
#pragma　
warning（pop）向栈中弹出最后一个警告信息，在入栈和出栈之间所作的
一切改动取消。例如：　


#pragma　
warning（push）　


#pragma　
warning（　
disable：　
4705　
）　



#pragma　
warning（　
disable：　
4706　
）　
#pragma　
warning（　
disable：　
4707　
）　
//。。。。。。。　
#pragma　
warning（　
pop）


在这段代码的最后，重新保存所有的警告信息（包括　
4705，4706和　
4707）。

3。6。7，#pragma　
ment　
#pragma　
ment（。。。）

该指令将一个注释记录放入一个对象文件或可执行文件中。

常用的　
lib关键字，可以帮我们连入一个库文件。比如：　


#pragma　
ment（lib；〃user32。lib〃）

该指令用来将　
user32。lib库文件加入到本工程中。　


linker：将一个链接选项放入目标文件中；你可以使用这个指令来代替由命令行传入的或
者在开发环境中设置的链接选项；你可以指定/include选项来强制包含某个对象；例如：　
#pragma　
ment（linker；〃/include：__mySymbol〃）

3。6。8，#pragma　
pack
这里重点讨论内存对齐的问题和#pragmapack（）的使用方法。

什么是内存对齐？

先看下面的结构：　


structTestStruct1　


｛　
char　
c1；　
shorts；　
char　
c2；　
inti；　


｝；

假设这个结构的成员在内存中是紧凑排列的，假设　
c1的地址是　
0，那么　
s的地址就应该
是　
1，c2的地址就是　
3，i的地址就是　
4。也就是　
c1地址为　
00000000；s地址为　
00000001；c2
地址为　
00000003；i地址为　
00000004。

可是，我们在　
VisualC＋＋6。0中写一个简单的程序：　


structTestStruct1a；　


printf（〃c1％p；s％p；c2％p；i　
％pn〃；　
（unsignedint）（void*）&a。c1…（unsigned　
int）（void*）&a；　
（unsignedint）（void*）&a。s　
…（unsignedint）（void*）&a；　
（unsignedint）（void*）&a。c2…（unsigned　
int）（void*）&a；　
（unsignedint）（void*）&a。i　
…（unsignedint）（void*）&a）；


运行，输出：　
c100000000；s00000002；c200000004；i00000008。



为什么会这样？这就是内存对齐而导致的问题。

3。6。8。1，为什么会有内存对齐？
字，双字，和四字在自然边界上不需要在内存中对齐。（对字，双字，和四字来说，自
然边界分别是偶数地址，可以被　
4整除的地址，和可以被　
8整除的地址。）无论如何，为了
提高程序的性能，数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为
了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访
问。

一个字或双字操作数跨越了　
4字节边界，或者一个四字操作数跨越了　
8字节边界，被
认为是未对齐的，从而需要两次总线周期来访问内存。一个字起始地址是奇数但却没有跨
越字边界被认为是对齐的，能够在一个总线周期中被访问。某些操作双四字的指令需要内
存操作数在自然边界上对齐。如果操作数没有对齐，这些指令将会产生一个通用保护异常。
双四字的自然边界是能够被　
16整除的地址。其他的操作双四字的指令允许未对齐的访问
（不会产生通用保护异常），然而，需要额外的内存总线周期来访问内存中未对齐的数据。

缺省情况下，编译器默认将结构、栈中的成员数据进行内存对齐。因此，上面的程序输
出就变成了：c100000000；s00000002；c200000004；i　
00000008。编译器将未对齐的成员向后
移，将每一个都成员对齐到自然边界上，从而也导致了整个结构的尺寸变大。尽管会牺牲
一点空间（成员之间有部分内存空闲），但提高了性能。也正是这个原因，我们不可以断言　
sizeof（TestStruct1）的结果为　
8。在这个例子中，sizeof（TestStruct1）的结果为　
12。

3。6。8。2，如何避免内存对齐的影响
那么，能不能既达到提高性能的目的，又能节约一点空间呢？有一点小技巧可以使用。
比如我们可以将上面的结构改成：　


structTestStruct2　


｛　


char　
c1；　


char　
c2；　


shorts；　


inti；　


｝；

这样一来，每个成员都对齐在其自然边界上，从而避免了编译器自动对齐。在这个例
子中，sizeof（TestStruct2）的值为　
8。这个技巧有一个重要的作用，尤其是这个结构作为　
API
的一部分提供给第三方开发使用的时候。第三方开发者可能将编译器的默认对齐选项改变，
从而造成这个结构在你的发行的　
DLL中使用某种对齐方式，而在第三方开发者哪里却使用
另外一种对齐方式。这将会导致重大问题。

比如，TestStruct1结构，我们的　
DLL使用默认对齐选项，对齐为　
c100000000；s00000002；c200000004；i　
00000008，同时　
sizeof（TestStruct1）的值为　
12。
而第三方将对齐选项关闭，导致　
c100000000；s00000001；c200000003；i　
00000004，同时　
sizeof（TestStruct1）的值为　
8。

除此之外我们还可以利用#pragma　
pack（）来改变编译器的默认对齐方式（当然一般编译器


也提供了一些改变对齐方式的选项，这里不讨论）。

使用指令#pragma　
pack　
（n），编译器将按照　
n个字节对齐。

使用指令#pragma　
pack　
（），编译器将取消自定义字节对齐方式。

在#pragma　
pack　
（n）和#pragma　
pack　
（）之间的代码按　
n个字节对齐。

但是，成员对齐有一个重要的条件　
；即每个成员按自己的方式对齐。也就是说虽然指定了
按　
n字节对齐；但并不是所有的成员都是以　
n字节对齐。其对齐的规则是　
；每个成员按其类型
的对齐参数（通常是这个类型的大小）和指定对齐参数（这里是　
n字节）中较小的一个对齐，即：　
min（　
n；sizeof（　
item　
））。并且结构的长度必须为所用过的所有对齐参数的整数倍；不够就补空
字节。看如下例子：　


#pragma　
pack（8）　


structTestStruct4　


｛　
char　
a；　
long　
b；　


｝；　


structTestStruct5　


｛　
char　
c；　
TestStruct4　
d；　
longlonge；　


｝；　


#pragma　
pack（）

问题：　


A）；sizeof（TestStruct5）=？　


B）；TestStruct5的　
c后面空了几个字节接着是　
d？　
TestStruct4中；成员　
a是　
1字节默认按　
1字节对齐；指定对齐参数为　
8；这两个值中取　
1；a
按　
1字节对齐；成员　
b是　
4个字节；默认是按　
4字节对齐；这时就按　
4字节对齐；所以　
sizeof（TestStruct4）应该为　
8；　


TestStruct5中；c和　
TestStruct4中的　
a一样；按　
1字节对齐；而　
d是个结构；它是　
8个字节；它
按什么对齐呢？对于结构来说；它的默认对齐方式就是它的所有成员使用的对齐参数中最大
的一个；TestStruct4的就是　
4。所以；成员　
d就是按　
4字节对齐。成员　
e是　
8个字节；它是默认按　
8
字节对齐；和指定的一样；所以它对到　
8字节的边界上；这时；已经使用了　
12个字节了；所以又添
加了　
4个字节的空；从第　
16个字节开始放置成员　
e。这时；长度为　
24；已经可以被　
8（成员　
e按　
8
字节对齐）整除。这样；一共使用了　
24个字节。内存布局如下（*表示空闲内存，1表示使用内存。

单位为　
1byete）：　
a　
b　
TestStruct4的内存布局：1***；1111；　
c　
TestStruct4。a　
TestStruct4。b　
d　
TestStruct5的内存布局：　
1***；　
1***；　
1111；　
****，11111111　



这里有三点很重要：
首先，每个成员分别按自己的方式对齐；并能最小化长度。
其次，复杂类型（如结构）的默认对齐方式是它最长的成员的对齐方式；这样在成员是复杂
类型时；可以最小化长度。
然后，对齐后的长度必须是成员中最大的对齐参数的整数倍；这样在处理数组时可以保
证每一项都边界对齐。

补充一下；对于数组；比如：char　
a＇3＇；它的对齐方式和分别写　
3个　
char是一样的。也就是说
它还是按　
1个字节对齐。如果写：　
typedef　
charArray3＇3＇；Array3这种类型的对齐方式还是按　
1
个字节对齐；而不是按它的长度。

但是不论类型是什么；对齐的边界一定是　
1；2；4；8；16；32；64。。。。中的一个。

另外，注意别的#pragma　
pack的其他用法：　


#pragma　
pack（push）　
//保存当前对其方式到　
packingstack　


#pragma　
pack（push；n）等效于　


#pragma　
pack（push）　


#pragma　
pack（n）　
//n=1；2；4；8；16保存当前对齐方式，设置按　
n字节对齐　


#pragmapack（pop）　
//packingstack出栈，并将对其方式设置为出栈的对齐方

3。7；#运算符　
#也是预处理？是的，你可以这么认为。那怎么用它呢？别急，先看下面例子：　


#defineSQR（x）　
printf（〃Thesquareof　
x　
is％d。n〃；（（x）*（x）））；

如果这样使用宏：　


SQR（8）；

则输出为：　


Thesquareof　
x　
is64。
注意到没有，引号中的字符　
x被当作普通文本来处理，而不是被当作一个可以被替换的语言
符号。

假如你确实希望在字符串中包含宏参数，那我们就可以使用　
“#”，它可以把语言符号转
化为字符串。上面的例子改一改：　


#defineSQR（x）　
printf（〃Thesquareof　
〃#x〃　
is％d。n〃；（（x）*（x）））；

再使用：　


SQR（8）；

则输出的是：　


Thesquareof　
8　
is64。
很简单吧？相信你现在已经明白#号的使用方法了。


3。8，##预算符
和#运算符一样，##运算符可以用于宏函数的替换部分。这个运算符把两个语言符号组


合成单个语言符号。看例子：　


#define　
XNAME（n）　
x##n

如果这样使用宏：　


XNAME（8）

则会被展开成这样：　


x8

看明白了没？##就是个粘合剂，将前后两部分粘合起来。


第四章指针和数组

几乎每次讲课讲到指针和数组时，我总会反复不停的问