久久久久人妻精品一区二区三区,www.久久99,久久综合久久鬼色

Xiao.Zhu — Fri, 28 Nov 2008 00:41:00 GMT

---Sailor_forever分析整理�Q?a href="mailto:sailing_9806@163.com">sailing_9806@163.com
1、预处理器（Preprocessor�Q?.. 1
2、如何定义宏... 2
3、预处理器标�?error的目的是什么？... 4
4、死循环�Q�Infinite loops�Q?.. 4
5、数据声明（Data declarations�Q?.. 5
6、关键字static的作用是什么？... 6
7、关键字const有什么含意？... 7
8、Volatile的��?.. 9
9、位操作�Q�Bit manipulation�Q?.. 12
10、访问固定的内存位置�Q�Accessing fixed memory locations�Q?.. 13
11、中断（Interrupts�Q?.. 13
12、符��h��展的代码例子�Q�Code examples�Q?.. 15
13、处理器字长��D��的数据扩展问�?.. 16
14、动态内存分配（Dynamic memory allocation�Q?.. 16
15、用Typedef构造复合类�?.. 17
16、晦涩的语法及代码风�?.. 18

C语言��试是招聘嵌入式�pȝ��E�序员过�E�中必须而且有效的方法。这些年�Q�我既参加也�l�织了许多这�U�测试，在这�q�程中我意识到这些测试能为面试者和被面试者提供许多有用信息，此外�Q�撇开面试的压力不谈，�q�种��试也是相当有趣的�?

�? 被面试者的角度来讲�Q�你能了解许多关于出题者或监考者的情况。这个测试只是出题者�ؓ昄��其对ANSI标准�l�节的知识而不是技术技巧而设计吗�Q�这是个愚蠢�? 问题吗？如要你答出某个字�W�的ASCII倹{��这些问题着重考察你的�pȝ��调用和内存分配策略方面的能力吗？�q�标志着出题者也许花旉��在微��Z��而不是在嵌入�? �pȝ��上。如果上�q�C�Q何问题的�{�案�?�?的话�Q�那么我知道我得认真考虑我是否应该去做这份工作�?

从面试者的角度来讲�Q�一个测试也许能从多斚w��揭示应试者的素质�Q�最基本的，你能了解应试者C语言的水�q�뀂不��怎么��P��看一下这人如何回�{�他不会的问题也是满有趣。应试者是以好的直觉做出明�? 的选择�Q�还是只是瞎蒙呢�Q�当应试者在某个问题上卡住时是找借口呢，�q�是表现出对问题的真正的好奇心，把这看成学习的机会呢�Q�我发现�q�些信息与他们的��试�? �l�一��h��用�?

有了�q�些��x��Q�我军_��Z��些真正针对嵌入式�pȝ��的考题�Q�希望这些��o人头痛的考题能给正在扑ַ�作的��Z��点帮助。这些问题都是我�q�些�q�实际碰到的。其中有些题很难�Q�但它们应该都能�l�你一点启�q��?

�q�个��试适于不同水��^的应试者，大多数初�U�水�q�的应试者的成�W会很差，�l�验丰富的程序员应该有很好的成�W。�ؓ了让你能自己军_��某些问题的偏好，每个问题没有分配分数�Q�如果选择�q�些考题��Z��所用，误��行按你的意思分配分数�?

1、预处理器（Preprocessor�Q?
用预处理指��o#define 声明一个常敎ͼ�用以表明1�q�中有多��秒�Q�忽略闰�q�问题）

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL�Q�大��写都行�Q�常量后面可以加此标志，宏的命名风格要大写，多个之间用下划线�Q?

我在�q�想看到几�g事情�Q?

1) #define 语法的基本知识（例如�Q�不能以分号�l�束�Q�括��L��使用�Q�表辑ּ�、参数等要括��h��Q�，�{�等�Q?

2)懂得预处理器��ؓ你计��常数表辑ּ�的��|��N��不是替换么，先算再替�Q�会��常数合�qӞ��Q�因此，直接写出你是如何计算一�q�中有多��秒而不是计��出实际的��|��是更清晰而没有代��L��?

3) 意识到这个表辑ּ��一�?6位机的整型数溢出-因此要用到长整型�W�号L,告诉�~�译器这个常数是的长整型数�?

4) 如果你在你的表达式中用到UL�Q�表�C�无�W�号长整型）�Q�那么你有了一个好的�v炏V��记住，�W�一印象很重要�?br>
2、如何定义宏
写一�?标准"宏MIN �Q�这个宏输入两个参数�q�返回较��的一个�?br>
考点�Q�（表达式、参数等要括��h��Q?

#define MIN(A,B) �Q�（A�Q?<= (B) ? (A) : (B))

�q�个��试是�ؓ下面的目的而设的：

1) 标识#define在宏中应用的基本知识。这是很重要的。因为在嵌入(inline)操作�W�变为标准C的一部分之前�Q�宏是方便��生嵌入代码的唯一�Ҏ��Q�对于嵌入式�pȝ��来说�Q��ؓ了能辑ֈ�要求的性能�Q�当然主要是实时性哦�Q�牺牲代码空间换取时间效率）�Q�嵌入代码经常是必须的方法�?

2)三重条�g操作�W�的知识。这个操作符存在C语言中的原因是它使得�~�译器能产生比if-then-else�Q�存在条件�{�U�M��中断指��o��水�U�）更优化的代码�Q�了解这个用法是很重要的�?

3) 懂得在宏中小心地把参数用括号括�v�?

4) 我也用这个问题开始讨论宏的副作用�Q�例如：当你写下面的代码时会发生什么事�Q?

least = MIN(*p++, b);

此处考点�Q�inline函数和宏的区�?br>
�? 只是��参数完全替换，即MIN(*p++, b)�q�行宏展开后�ؓ�Q�（*p++�Q?<= (b) ? (*p++) : (b))�Q�如果（*p++�Q?<= (b)成立�Q�则表达式的��gؓ(*p++)�Q�但�׃��在（*p++�Q?lt;= (b)判断�q�程中改变了p的��|��使得此时�? (*p++)非（*p++�Q?lt;= (b)中的��g��Q�违背了�Q�号表达式的原意�?br>
但是内联inline函数��进行参数检查，求出参数的值后再将此值带入函��C��Q�因此（�Q�A�Q?<= (B) ? (A) : (B))中的A是一致的�?br>

�W�一部分�Q�宏
��Z��么要使用宏呢�Q?br>�? 为函数的调用必须要将�E�序执行的顺序�{�U�d��函数所存放在内存中的某个地址�Q�将函数的程序内�Ҏ��行完后，再返回到转去执行该函数前的地斏V��这�U��{�U�L��作要�? 在�{��L��行前要保存现场�ƈ记忆执行的地址�Q��{回后要恢复现场，�q�按原来保存地址�l�箋执行。因此，函数调用要有一定的旉��和空间方面的开销�Q�于是将影响其效率�?br>而宏只是在预处理的地�Ҏ��代码展开�Q�不需要额外的�I�间和时间方面的开销�Q�所以调用一个宏比调用一个函数更有效率�?br>但是宏也有很多的不尽人意的地斏V�?br>1、宏不能讉K��对象的私有成员�?br>2、宏的定义很�Ҏ��产生二意性�?br>
3、宏定义的常量在代码区，很多调试器不能够对其调试
我们举个例子�Q?br>#define square(x) (x*x)

避免�q�些错误的方法，一是给宏的参数都加上括受��?br>#define square(x) ((x)*(x))

�W�二部分�Q�内联函�?br>从上面的阐述�Q�可以看到宏有一些难以避免的问题�Q�怎么解决呢？
内联函数是代码被插入到调用者代码处的函数。如�?#define 宏，内联函数通过避免被调用的开销来提高执行效率，��其是它能够通过调用�Q?#8220;�q�程化集�?#8221;�Q�被�~�译器优化�?br>

�? 联函数和宏很�c�M��Q�而本质区别在于，宏是由预处理器对宏进行替代，而内联函数是通过�~�译器控制来实现的。而且内联函数是真正的函数�Q�只是在需要用到的�? 候，内联函数像宏一��L��展开�Q�所以取消了函数的参数压栈，减少了调用的开销。你可以象调用函��C��h��调用内联函数�Q�而不必担心会产生于处理宏的一些问题�?br>声明内联函数看上��d��普通函数非常相��|��
void f(int i, char c);
当你定义一个内联函数时�Q�在函数定义前加�?inline 关键字，�q�且��定义放入头文�g�Q?br>inline void f(int i, char c)
{
// ...
}
内联函数必须是和函数体的定义��x��在一��P��才有效�?br>像这��L��x��inline function(int i)是没有效果的�Q�编译器只是把函��C��为普通的函数��x��Q�我们必��d��义函��C��?br>inline int function(int i) {return i*i;}
�q�样我们才算定义了一个内联函数。我们可以把它作��Z��般的函数一栯��用。但是执行速度��比一般函数的执行速度要快�?br>

当然�Q�内联函��C��有一定的局限性。就是函��C��的执行代码不能太多了�Q�如果，内联函数的函��C��q�大�Q�一般的�~�译器会攑ּ�内联方式�Q�而采用普通的方式调用函数。这��P��内联函数��和普通函数执行效率一样了�?br>有上面的两者的�Ҏ��，我们可以用内联函数完全取代预处理宏�?br>

3、预处理器标�?error的目的是什么？
如果你不知道�{�案�Q�请看参考文�?。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去扑և�象这�U�问题的�{�案。当然如果你不是在找一个书呆子�Q�那么应试者最好希望自�׃��要知道答案�?br>

4、死循环�Q�Infinite loops�Q?
嵌入式系�l�中�l�常要用到无限��@环，你怎么��L��C�~�写��d�@环呢�Q?�q�个问题用几个解��x��案�?

我首选的�Ҏ��是：

while(1)

{

}

一些程序员更喜�Ƣ如下方案：

for(;;) �Q�此处的判断效率要低的多�Q�在汇编代码中看看？�Q�？�Q?br>
{

}

�q? 个实现方式让我�ؓ难，因�ؓ�q�个语法没有��切表达到底怎么回事。如果一个应试者给��个作为方案，我将用这个作��Z��个机会去探究他们�q�样做的基本原理。如�? 他们的基本答案是�Q?我被教着�q�样做，但从没有惛_��q��ؓ什么�?�q�会�l�我留下一个坏印象�? �Q�很多时候面试官��x��你思考问题的方式�Q�是否留意某些东西善于思考，可能�q�没有对错，只是偏好而已�Q�比如memset和memcopy以及strcpy�? 能拷贝字�W�串�Q�到底有什么区别呢�Q�看你是否善于比较是否关注细节）

�W�三个方案是�?goto �Q�goto语句在C中是应该��量避免的，只在处理错误代码时用�Q?br>
Loop:

...

goto Loop;

应试者如�l�出上面的方案，�q�说明或者他是一个汇�~�语�a��E�序员（�q�也许是好事�Q�或者他是一个想�q�入新领域的BASIC/FORTRAN�E�序员�?

5、数据声明（Data declarations�Q?
用变量a�l�出下面的定�?

a) 一个整型数�Q�An integer�Q?

b)一个指向整型数的指针（ A pointer to an integer�Q?

c)一个指向指针的的指针，它指向的指针是指向一个整型数�Q?A pointer to a pointer to an integers�Q?

d)一个有10个整型数的数�l�（ An array of 10 integers�Q?

e) 一个有10个指针的数组�Q�该指针是指向一个整型数的。（An array of 10 pointers to integers�Q?

f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers�Q?

g) 一个指向函数的指针�Q�该函数有一个整型参数�ƈ�q�回一个整型数�Q�A pointer to a function that takes an integer as an argument and returns an integer�Q?

h) 一个有10个指针的数组�Q�该指针指向一个函敎ͼ�该函数有一个整型参数�ƈ�q�回一个整型数�Q?An array of ten pointers to functions that take an integer argument and return an integer �Q?

�{�案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer // 不是�Q�int x�Q�，不需要具体的参数

h) int (*a[10])(int)�Q�可以从e、g�c�L��得到�Q? // An array of 10 pointers to functions that take an integer argument and return an integer

�? 们经常声�U�这里有几个问题是��U�要��M��下书才能回答的问题，我同意这�U�说法。当我写�q�篇文章�Ӟ��Z��定语法的正��性，我的��查了一下书。但是当我被面试的时候，我期望被问到�q�个问题�Q�或者相�q�的问题�Q�。因为在被面试的�q�段旉��里，我确定我知道�q�个问题的答案。应试者如果不知道所有的�{�案�Q�或臛_��大部分答案）�Q�那么也��没有�ؓ�q�次面试做准备，如果该面试者没有�ؓ�q�次面试做准备，那么他又能�ؓ什么做准备呢？

6、关键字static的作用是什么？
�q�个��单的问题很少有�h能回�{�完全。在C语言中，关键字static有三个明昄��作用�Q?

1)在函��C��内，一个被声明为静态的变量在这一函数被调用过�E�中�l�持其��g��变（该变量存攑֜�静态变量区�Q��?

2) 在模块内�Q�但在函��C��外）�Q�一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量�?

3) 在模块内�Q�一个被声明为静态的函数只可被这一模块内的其它函数调用。那��是�Q�这个函数被限制在声明它的模块的本地范围内��用�?

大多数应试者能正确回答�W�一部分�Q�一部分能正��回�{�第二部分，但是很少的�h能懂得第三部分。这是一个应试者的严重的缺点，因�ؓ他显然不懂得本地化数据和代码范围的好处和重要性�?

考点�Q�在嵌入式系�l�中�Q�要时刻懂得�U�L��的重要性，�E�序可能是很多程序员共同协作同时完成�Q�在定义变量及函数的�q�程�Q�可能会重名�Q�这�l�系�l�的集成带来�ȝ��Q�因此保证不冲突的办法是昄��的表�C�此变量或者函数是本地的，static卛_��?br>
在Linux的模块编�E�中�Q�这一条很明显�Q�所有的函数和全局变量都要用static关键字声明，��其作用域限制在本模块内部，与其他模块共享的函数或者变量要EXPORT到内�怸��?br>

static关键字至��有下列n个作用：
�Q?�Q�设�|�变量的存储域，函数体内static变量的作用范围�ؓ该函��C��Q�不同于auto变量�Q�该变量的内存只被分配一�ơ，因此其值在下次调用时仍�l�持上次的��|��

�Q?�Q�限制变量的作用域，在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；

�Q?�Q�限制函数的作用域，在模块内的static函数只可被这一模块内的其它函数调用�Q�这个函数的使用范围被限制在声明它的模块内；
�Q?�Q�在�c�M��的static成员变量意味着它�ؓ该类的所有实例所�׃�n�Q�也��是说当某个�cȝ��实例修改了该静态成员变量，其修改��gؓ该类的其它所有实例所见；
�Q?�Q�在�c�M��的static成员函数属于整个�c�L��拥有�Q�这个函��C��接收this指针�Q�因而只能访问类的static成员变量�?br>

7、关键字const有什么含意？
�? 只要一听到被面试者说�Q?const意味着常数"�Q�不是常敎ͼ�可以是变量，只是你不能修改它�Q�，我就知道我正在和一个业余者打交道。去�q�Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什�?如果你从没有��d��那篇文章�Q�只要能说出const意味着"只读"��可以了。尽��这个答案不是完全的�{�案�Q�但我接受它作�ؓ一个正��的�{�案。（如果你想知道更详�l�的�{�案�Q�仔�l�读一下Saks的文章吧。）

如果应试者能正确回答�q�个问题�Q�我��问他一个附加的问题�Q�下面的声明都是什么意思？

Const只是一个修饰符�Q�不��怎么样a仍然是一个int型的变量

const int a;

int const a;

const int *a;

int * const a;

int const * a const;

本质�Q�const在谁后面谁就不可修改�Q�const在最前面则将其后�U�M��位即可，二者等�?br>

前两个的作用是一��P��a是一个常整型数。第三个意味着a是一个指向常整型数的指针�Q�也��是�Q�指向的整型数是不可修改的，但指针可以，此最常见于函数的参数�Q�当你只引用传进来指针所指向的值时应该加上const修饰�W�，�E�序中修改编译就不通过�Q�可以减��程序的bug�Q��?br>

�W�四个意思a是一个指向整型数的常指针�Q�也��是��_��指针指向的整型数是可以修改的�Q�但指针是不可修改的�Q�。最后一个意味着a是一个指向常整型数的常指针（也就是说�Q�指针指向的整型数是不可修改的，同时指针也是不可修改的）�?br>

如果应试者能正确回答�q�些问题�Q�那么他��q��我留下了一个好印象。顺带提一句，也许你可能会问，即��不用关键�?�Q�也�q�是能很�Ҏ��写出功能正确的程序，那么我�ؓ什么还要如此看重关键字const呢？我也如下的几下理由：

1) 关键字const的作用是为给��M��代码的�h传达非常有用的信息，实际上，声明一个参��Cؓ帔R��是�ؓ了告诉了用户�q�个参数的应用目的。如果你曾花很多旉��清理其它人留下的垃圾�Q�你��׃��很快学会感谢�q�点多余的信息。（当然�Q�懂得用const的程序员很少会留下的垃圾让别人来清理的。）

2) 通过�l�优化器一些附加的信息�Q��用关键字const也许能��生更紧凑的代码�?

3) 合理��C��用关键字const可以使编译器很自然地保护那些不希望被改变的参敎ͼ�防止其被无意的代码修攏V��简而言之，�q�样可以减少bug的出现�?br>

const关键字至��有下列n个作用：

�Q?�Q�欲��L��一个变量被改变�Q�可以��用const关键字。在定义该const变量�Ӟ��通常需要对它进行初始化�Q�因��Z��后就没有��Z��再去改变它了�Q?br>�Q?�Q�对指针来说�Q�可以指定指针本�w��ؓconst�Q�也可以指定指针所指的数据为const�Q�或二者同时指定�ؓconst�Q?br>�Q?�Q�在一个函数声明中�Q�const可以修饰形参�Q�表明它是一个输入参敎ͼ�在函数内部不能改变其��|��
�Q?�Q�对于类的成员函敎ͼ�若指定其为const�c�d��Q�则表明其是一个常函数�Q�不能修改类的成员变量；
�Q?�Q�对于类的成员函敎ͼ�有时候必��L��定其�q�回��gؓconst�c�d��Q�以使得其返回��g��?#8220;左�?#8221;。例如：
const classA operator*(const classA& a1,const classA& a2);
　　operator*的返回结果必��L��一个const对象。如果不是，�q�样的变态代码也不会�~�译出错�Q?br>classA a, b, c;
(a * b) = c; // 对a*b的结果赋�?
　　操作(a * b) = c昄��不符合编�E�者的初衷�Q�也没有��M��意义�?br>

8、Volatile的��?br>关键字volatile有什么含�?�q�给��Z��个不同的例子�?

一个定义�ؓvolatile的变量是说这变量可能会被意想不到地改变，�q�样�Q�编译器��׃��会去假设�q�个变量的��g��。精��地说就是，优化器在用到�q�个变量时必��? 每次都小心地重新��d��q�个变量的��|��而不是��用保存在寄存器里的备份（�׃��讉K��寄存器的速度要快�q�RAM�Q�所以编译器一般都会作减少存取外部RAM的优化）。下面是volatile变量的几个例子：

1) �q�行讑֤�的硬件寄存器�Q�如�Q�状态寄存器�Q�通常在头文�g中将��g寄存器地址define为某个意义明��的表达式）

2) 一个中断服务子�E�序中会讉K��到的非自动变�?Non-automatic variables�Q�即static变量) �Q�在中断服务�E�序中修改的供其他程序检��用的变量需要加volatile声明�Q�否则编译器可能对变量更��C��ơ后每次都��用缓存��g��再立��x��斎ͼ�

3) 多线�E�应用中被几个�Q务共享的变量�Q�可能被多个�U�程随时修改�Q?

�? �{�不��个问题的人是不会被雇佣的。我认�ؓ�q�是区分C�E�序员和嵌入式系�l�程序员的最基本的问题。搞嵌入式的家伙们经常同��g、中断、RTOS�{�等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。假设被面试者正��地回答了这是问题（嗯，怀疑是否会是这��P��Q�我��? �E�微��q��一下，看一下这家伙是不是直正懂得volatile完全的重要性�?

1)一个参数既可以是const�q�可以是volatile吗？解释��Z��么�?

2); 一个指针可以是volatile 吗？解释��Z��么�?

3); 下面的函数有什么错误：

int square(volatile int *ptr)

{

return *ptr * *ptr;

}

下面是答案：

1)是的。一个例子是只读的状态寄存器。它是volatile因�ؓ它可能被意想不到地改变。它是const因�ؓ�E�序不应该试囑֎�修改它�?

2); 是的。尽��这�q�不很常见。一个例子是当一个中断服务子�E�序修改一个指向一个buffer的指针时�?

3) �q�段代码有点变态。这�D�代码的目的是用来返回指�?ptr指向值的�q�x��Q�但是，�׃��*ptr指向一个volatile型参敎ͼ��~�译器将产生�c�M��下面的代码：

int square(volatile int *ptr)

{

int a,b;

a = *ptr;

b = *ptr;

return a * b;

}

�׃��*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，�q�段代码可能�q�不是你所期望的��^方��|��正确的代码如下：

long square(volatile int *ptr)

{

int a;

a = *ptr;

return a * a;

}

关于volatile关键字在中断函数中的影响实例

串口发送数据，中断中对其检��，当中断��生后�Q�置接收标志�Q�主循环中检��此��L��志，未用valotile修饰�Ӟ��~�译�l�果如下�Q?br>

[0xe59f41bc] ldr r4�Q?x30203378 ; = #0x302096f0

0x302031b8 [0xe5d40000] ldrb r0�Q�[r4�Q?0]

while(!uart1_rxFlag); //uart1_rxFlag为全局变量�Q�在串口接收中断中置1

0x302031bc [0xe3500000] cmp r0�Q?0

0x302031c0 [0x0afffffd] beq 0x302031bc; (Can_Int_Test + 0x17c)

�? �~�译器对其进行了优化�Q�读取一�ơuart1_rxFlag的��g��后，��其存放在寄存器r0中，比较后，条�g不满��I��l�箋�{�待�Q�但未重新取存储器中 uart1_rxFlag的��|��此时即��中断服务函数中修改了uart1_rxFlag的��|��比较处仍然不能发玎ͼ��出��C��无论如何�E�序��停在此处的�? 题�?br>

// 加了volatile关键字后�Q�编译的�l�果

302031b4 ldr r4�Q?x30203378 ; = #0x302096f0

while(uart1_rxFlag == 0);

302031b8 [0xe5d40000] ldrb r0�Q�[r4�Q?0]

302031bc [0xe3500000] cmp r0�Q?0

302031c0 [0x0afffffc] beq 0x302031b8 ; (Can_Int_Test + 0x288)

��d��了关键字后，比较不等�Q�蟩转到重新取存储器中的uart1_rxFlag�Q�因此�Q何时候uart1_rxFlag的值都是最新的�?br>
一定程度的优化�Q�去掉了��d��uart1_rxFlag地址的语句�?br>

�? 义一个易失性变量，�~�译器有一�U�技术叫数据��分析，分析�E�序中的变量在哪里被赋倹{��在哪里使用、在哪里失效�Q�分析结果可以用于常量合�qӞ��帔R��传播�{�优化�? 当编译器��查到代码没有修改字段的��|��有可能在你讉K��字段时提供上�ơ访问的�~�存��|��q�能够提高程序的效率�Q�但有时�q�些优化会带来问题，不是我们�E�序所需要的�Q�特�Ҏ��对硬件寄存器操作的程序，�q�时可以用volatile关键字禁止做�q�些优化�?br>

多�Q务环境下各�Q务间�׃�n的标志应该加voatile关键字：在多�U�程讉K��某字�D�|��Q�代码希望这些访问能够操作（��d��Q�到字段的最新��|��同时写到变量的操作能立即更新�Q�对字段加上volatile关键字，那么对该字段的�Q何请求（�?写）都会立刻得到执行�?br>

9、位操作�Q�Bit manipulation�Q?
嵌入式系�l��L��要用户对变量或寄存器�q�行位操作。给定一个整型变量a�Q�写两段代码�Q�第一个设�|�a的bit 3�Q�第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变�?对这个问题有三种基本的反�?

1)不知道如何下手。该被面者从没做�q��Q何嵌入式�pȝ��的工作�?

2) 用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同�~�译器之间是不可�U�L��的，同时也保证了的你的代码是不可重用的�?br>
3) �?#defines �?bit masks 操作。这是一个有极高可移植性的�Ҏ��Q�是应该被用到的�Ҏ��。最佳的解决�Ҏ��如下�Q?

#define BIT3 (0x1 << 3) �Q�采用宏��数字定义�ؓ有意义的BIT3�Q�明��，不易出错�Q�改��h��方便�Q?br>
static int a;

void set_bit3(void)

{

a |= BIT3;

}

void clear_bit3(void)

{

a &= ~BIT3;

}

一些�h喜欢��|�和清除��D��定义一个掩码（待操作位�?�Q�其余位�?的数�Q�对于某个意义靠多位同时表示的最好带上掩码，隔离其他位的影响�Q�同时定义一些说�? 常数�Q�这也是可以接受的。我希望看到几个要点�Q�说明常数、|=�?amp;=~操作�Q�先取反�?amp;是对某位�?的最好操作�?

考点�Q?br>
在嵌入式�pȝ��中，时刻要关注移植性，具体的程序中不要出现具体的数字，�q�些数字都应该define成某个有意义的符��P��可读性可�U�L��性都很强�Q�比�?br>
#define BIT(x) (0x1 << (x))

X作�ؓ参数可以很方便的对�Q意位�q�行操作�Q�意义明��，更改替换方便

10、访问固定的内存位置�Q�Accessing fixed memory locations�Q?
嵌入式系�l�经常具有要求程序员去访问某特定的内存位�|�的特点�?

�? 某工�E�中�Q�要求设�|�一�l�对地址�?x67a9的整型变量的��gؓ0xaa66。编译器是一个纯�_�的ANSI�~�译器。写代码��d��成这一��d��。这一问题��试你是否知道�ؓ了访问一�l�对地址把一个整型数强制转换�Q�typecast�Q��ؓ一指针是合法的。这一问题的实现方式随着个�h风格不同而不同。典型的�c�M��代码如下�Q?

int *ptr;

ptr = (int *)0x67a9;

*ptr = 0xaa55;

A more obscure approach is: ( 一个较晦�ӆ的方法是)�Q?

*(int * const)(0x67a9) = 0xaa55;

即��你的品味更接�q�第二种�Ҏ��Q�但我徏议你在面试时使用�W�一�U�方案�?

在嵌入式�pȝ��中，对于大量此类型数据如��g寄存器应该采用如下方�?br>
typedef volatile unsigned int HARD_REG;

#define REG_NAME (*(HARD_REG *)ADDR)

卛_��ADDR强制转换��Z��个指向HARD_REG�c�d��数据的指针，*HARD_REG为volatile的无�W�号整型�?br>

11、中断（Interrupts�Q?
�? 断是嵌入式系�l�中重要的组成部分，�q�导致了很多�~�译开发商提供一�U�扩�?让标准C支持中断。其代表事实是，产生了一个新的关键字 __interrupt�Q?1卛_��此）。下面的代码��׃��用了__interrupt关键字去定义了一个中断服务子�E�序(ISR)�Q�请评论一下这�D�代码的�?

__interrupt double compute_area (double radius)

{

double area = PI * radius * radius;

printf("\nArea = %f", area);

return area;

}

�q�个函数有太多的错误了，以至让�h不知从何说�v了（前提是非操作�pȝ��下的中断服务函数�Q�：

1)ISR 不能�q�回一个��|��都应该�ؓvoid�c�d��Q�。如果你不懂�q�个�Q�那么你不会被雇用的�?

2)ISR 不能传递参数。如果你没有看到�q�一点，你被雇用的机会等同第一��V�?

3)在许多的处理�?�~�译器中�Q��Q点一般都是不可重入的。有些处理器/�~�译器需要让额外的寄存器入栈�Q�有些处理器/�~�译器就是不允许在ISR中做��点�q�算。此外，ISR应该是短而有效率的，在ISR中做��点�q�算是不明智的�?

///////////////////////////////

另外中断服务�E�序是运行在内核态的�Q�linux�Q�，内核通常是不支持��点�q�算的�?br>
http://access911.net/n/doc1.asp?mode=a&aid=4750647

内核中的printk和标准库的printf不一��P��前者因为由内核直接实现�Q�不能支持��Q炏V�?br>
在＜linux内核设计与实玎ͼ�的第一章中内核开发的特点一��节里就有比较了内核开发与应用开发的差异。其中一点就是内核编�E�时��点数的问题�Q�书中有一句话是：内核�~�程时��Q�Ҏ��很难使用

因�ؓ没有��点单元,内核要支持��Q点必��L��内核以soft-float 方式重新�~�译,其连接所有的库也都要用soft-float 方式�~�译.

否则另外一�U�方式��用整数定义��Q点类型加��点预算库完成你的工�?

http://topic.csdn.net/u/20070417/16/a4b56569-228c-4b70-b5ab-30ee61c99a3d.html

如果你的内核里编译进了��Q�Ҏ��持，那么是可以的。要不内核或是模块不能用float或是double内型的变量或函数

在配�|�内核的时候把��点模拟器选上�Q�应该是可以支持的，但是速度非常慢�?
我曾�l�遇到过�Q�硬件明明支持��Q点运��的FPU�Q�但是编译内核的时候选上了��Q�Ҏ��拟器�Q�结果所有的应用�E�序的��Q点运��速度都非常慢。所以我怀疑要支持��点只要�~�译内核的时候选上�Q�对于应用程序不需要怎么兛_��?br>
///////////////////////////////

4) 与第三点一脉相承，printf()�l�常有重入和性能上的问题。如果你丢掉了第三和�W�四点，我不会太为难你的。不用说�Q�如果你能得到后两点�Q�那么你的被雇用前景��来��光明了�?

12、符��h��展的代码例子�Q�Code examples�Q?
下面的代码输出是什么，��Z��么？

void foo(void)

{

unsigned int a = 6;

int b = -20;

(a+b > 6) ? puts("> 6") : puts("<= 6");

}

Vc6.0��试情况

void main(void)

{

unsigned int a = 6;

int b = -20;

printf("unsigned int a + int b = %x\n", (a + b));

}

/*unsigned int a + int b = fffffff2*/

�q? 个问题测试你是否懂得C语言中的整数自动转换原则�Q�我发现有些开发者懂得极��这些东�ѝ��不��如何，�q�无�W�号整型问题的答案是输出�? ">6"。原因是当表辑ּ�中存在有�W�号�c�d��和无�W�号�c�d��时所有的操作数都自动转换为无�W�号�c�d��。因�?20变成了一个非常大的正整数�Q�所以该表达�? 计算出的�l�果大于6。这一点对于频�J�用到无�W�号数据�c�d��的嵌入式�pȝ��Q�硬件寄存器的值全部是无符��L��Q�来说是丰常重要的。如果你�{�错了这个问题，你也��到了得不到�q�䆾工作的边�~��?

13、处理器字长��D��的数据扩展问�?br>评�h下面的代码片断：

unsigned int zero = 0;

unsigned int compzero = 0xFFFF;

/*1's complement of zero */ 0的补码�ؓ�?的数

对于一个int型不�?6位的处理器�ؓ��_��上面的代码是不正��的。应�~�写如下�Q?

unsigned int compzero = ~0;

�q�一问题真正能揭露出应试者是否懂得处理器字长的重要性（嵌入式��^台可能是8�?6�?2的，�U�L��的角度来说写出固定的0xFFFF是不对的�Q�。在我的�l�验里，好的嵌入式程序员非常准确地明白硬件的�l�节和它的局限，然而PC机程序往往把硬件作��Z��个无法避免的烦恼�?

�? 了这个阶�D�，应试者或者完全垂头��气了或者信心满满志在必得。如果显然应试者不是很好，那么�q�个��试��在�q�里�l�束了。但如果昄��应试者做得不错，那么我就扔出下面的追加问题，�q�些问题是比较难的，我想仅仅非常优秀的应试者能做得不错。提��些问题，我希望更多看到应试者应付问题的�Ҏ��Q�很重要哦，面试者关注的是你思考问题解决问题的�q�程�Q�当你不知道�{�案时千万千万不要猜一个答案给他，因�ؓ现在不是选择题，面试官要的是�q�程�Q�你只需要将你考虑问题的过�E�说�? 白就OK了）�Q�而不是答案。不��如何，你就当是�q�个�׃��?..

14、动态内存分配（Dynamic memory allocation�Q?
��? ��不像非嵌入式计��机那么常见�Q�嵌入式�pȝ��q�是有从堆（heap�Q�中动态分配内存的�q�程的。那么嵌入式�pȝ��中，动态分配内存可能发生的问题是什么？�q�里�Q? 我期望应试者能提到内存��片�Q�碎片收集的问题�Q�变量的持行旉��{�等。这个主题已�l�在ESP杂志中被�q�泛地讨��了（主要�?P.J. Plauger, 他的解释�q�远��过我这里能提到的�Q何解释）�Q�所有回�q�头看一下这些杂志吧�Q�让应试者进入一�U�虚假的安全感觉后，我拿��么一个小节目�Q�下面的代码片段的输出是什么，��Z��么？

char *ptr;

if ((ptr = (char *)malloc(0)) == NULL)

puts("Got a null pointer");

else

puts("Got a valid pointer");

�q? 是一个有��的问题。最�q�在我的一个同事不�l�意�?��g��l�了函数malloc�Q�得��C��一个合法的指针之后�Q�我才想到这个问题。这��是上面的代码，该代码的�? 出是"Got a valid pointer"。我用这个来开始讨��L��一问题�Q�看看被面试者是否想到库例程�q�样做是正确�Q�因为如果申请失败，则程序处理认为内存不��了�Q�一般会�l�止 �E�序�Q�是很严重的问题�Q�）。得到正��的�{�案固然重要�Q�但解决问题的方法和你做军_��的基本原理更重要些�?

�q�回一個控指針還是指向 0 字節的指針甚��x��向一个可以操作的指针�Q?br>
�Q�取决于�pȝ��q�_��的实玎ͼ�C99及其他标准规定可以不同的�Q?br>
malloc(0) in glibc returns a valid pointer to something(!?!?) while in uClibc calling malloc(0) returns a NULL. The behavior of malloc(0) is listed as implementation-defined by SuSv3, so both libraries are equally correct. This difference also applies to realloc(NULL, 0). I personally feel glibc's behavior is not particularly safe. To enable glibc behavior, one has to explicitly enable the MALLOC_GLIBC_COMPAT option.

15、用Typedef构造复合类�?
在C语言中频�J�用以声明一个已�l�存在的数据�c�d��的同义字。也可以用预处理器做�c�M��的事。例如，思考一下下面的例子�Q?

#define dPS struct s *

typedef struct s * tPS;

以上两种情况的意��N��是要定义dPS �?tPS 作�ؓ一个指向结构s指针。哪�U�方法更好呢�Q�（如果有的话）��Z��么？

�q�是一个非常微妙的问题�Q��Q何�h�{�对�q�个问题�Q�正当的原因哦，而不是猜�Q�如果你没有原因�Q�说不会比猜一个答案要好的多，��C��啊，说话是要讲根据的�Q�是应当被恭喜的。答案是�Q�typedef更好。思考下面的例子�Q?

dPS p1,p2;

tPS p3,p4;

�W�一个扩展�ؓ

struct s * p1, p2;

上面的代码定义p1��Z��个指向结构的指，p2��Z��个实际的�l�构�Q�这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针�?

16、晦涩的语法及代码风�?
C语言同意一些��o人震惊的�l�构,下面的结构是合法的吗�Q�如果是它做些什么？

int a = 5, b = 7, c;

c = a+++b;

�q�个问题��做��个测验的一个愉快的�l�尾。不��你�怸��怿��Q�上面的例子是完全合乎语法的。问题是�~�译器如何处理它�Q�水�q�不高的�~�译作者实际上会争��个问题，�~�译器应��可能多的从左至叛_��若干个字�W�组成一个运��符。因此，上面的代码被处理成：c = a++ + b;

逗号表达式依�ơ对每个表达式计��，最后的�l�果为最后一个表辑ּ�的�?br>
因此, �q�段代码执行后a = 6, b = 7, c = 12�?

如果你知道答案，或猜出正��答案，做得好。如果你不知道答案，我也不把�q�个当作问题。我发现�q�个问题的最大好处是�q�是一个关于代码编写风��|��要明��的加上括号�Q�避免歧义或者编译器不同带来的差异）�Q�代码的可读性，代码的可修改性的好的话题�?

注：引出代码风格的问题正是作者问此问题的目的�Q�这告诉我们要揣摩面试管每个问题背后隐藏的考查点，能够��机发挥下就大功告成了！

好了�Q�伙计们�Q�你现在已经做完所有的��试了。这��是我出的C语言��试题，我怀着愉快的心情写完它�Q�希望你以同��L��心情��d��它。如果是认�ؓ�q�是一个好的测试，那么��量都用��C��的找工作的过�E�中��d��。天知道也许�q�个一两年�Q�我��׃��做现在的工作�Q�也需要找一个�?

以下��Z��q?6个问题的英文表述�Q�熟悉下相关的专业词汇对于英文面试的��单表�q�很重要�?br>
http://www.yuanma.org/data/2007/0509/article_2585.htm

An obligatory and significant part of the recruitment process for embedded systems programmers seems to be the "C test." Over the years, I have had to both take and prepare such tests and, in doing so, have realized that these tests can be informative for both the interviewer and interviewee. Furthermore, when given outside the pressure of an interview situation, these tests can also be quite entertaining.

From the interviewee's perspective, you can learn a lot about the person who has written or administered the test. Is the test designed to show off the writer's knowledge of the minutiae of the ANSI standard rather than to test practical know-how? Does it test ludicrous knowledge, such as the ASCII values of certain characters? Are the questions heavily slanted towards your knowledge of system calls and memory allocation strategies, indicating that the writer may spend his time programming computers instead of embedded systems? If any of these are true, then I know I would seriously doubt whether I want the job in question.

From the interviewer's perspective, a test can reveal several things about the candidate. Primarily, you can determine the level of the candidate's knowledge of C. However, it's also interesting to see how the person responds to questions to which they don't know the answers. Do they make intelligent choices backed up with good intuition, or do they just guess? Are they defensive when they are stumped, or do they exhibit a real curiosity about the problem and see it as an opportunity to learn something? I find this information as useful as their raw performance on the test.

With these ideas in mind, I have attempted to construct a test that is heavily slanted towards the requirements of embedded systems. This is a lousy test to give to someone seeking a job writing compilers! The questions are almost all drawn from situations I have encountered over the years. Some of them are tough; however, they should all be informative.

This test may be given to a wide range of candidates. Most entry-level applicants will do poorly on this test, while seasoned veterans should do very well. Points are not assigned to each question, as this tends to arbitrarily weight certain questions. However, if you choose to adapt this test for your own uses, feel free to assign scores.

Preprocessor
1. Using the #define statement, how would you declare a manifest constant that returns the number of seconds in a year? Disregard leap years in your answer.

#define SECONDS_PER_YEAR

(60 * 60 * 24 * 365)UL

I'm looking for several things here:

Basic knowledge of the #define syntax (for example, no semi-colon at the end, the need to parenthesize, and so on)

An understanding that the pre-processor will evaluate constant expressions for you. Thus, it is clearer, and penalty-free, to spell out how you are calculating the number of seconds in a year, rather than actually doing the calculation yourself

A realization that the expression will overflow an integer argument on a 16-bit machine-hence the need for the L, telling the compiler to treat the variable as a Long

As a bonus, if you modified the expression with a UL (indicating unsigned long), then you are off to a great start. And remember, first impressions count!

2. Write the "standard" MIN macro-that is, a macro that takes two arguments and returns the smaller of the two arguments.

#define MIN(A,B)

((A)

<

= (B) ? (A) : (B))

The purpose of this question is to test the following:

Basic knowledge of the #define directive as used in macros. This is important because until the inline operator becomes part of standard C, macros are the only portable way of generating inline code. Inline code is often necessary in embedded systems in order to achieve the required performance level

Knowledge of the ternary conditional operator. This operator exists in C because it allows the compiler to produce more optimal code than an if-then-else sequence. Given that performance is normally an issue in embedded systems, knowledge and use of this construct is important

Understanding of the need to very carefully parenthesize arguments to macros

I also use this question to start a discussion on the side effects of macros, for example, what happens when you write code such as:

least = MIN(*p++, b);

3. What is the purpose of the preprocessor directive #error?

Either you know the answer to this, or you don't. If you don't, see Reference 1. This question is useful for differentiating between normal folks and the nerds. Only the nerds actually read the appendices of C textbooks to find out about such things. Of course, if you aren't looking for a nerd, the candidate better hope she doesn't know the answer.

Infinite loops
4. Infinite loops often arise in embedded systems. How does you code an infinite loop in C?

There are several solutions to this question. My preferred solution is:

while(1)

{

?

}

Many programmers seem to prefer:

for(;;)

{

?

}

This construct puzzles me because the syntax doesn't exactly spell out what's going on. Thus, if a candidate gives this as a solution, I'll use it as an opportunity to explore their rationale for doing so. If their answer is basically, "I was taught to do it this way and I haven't thought about it since," it tells me something (bad) about them.

A third solution is to use a goto :

Loop:

...

goto Loop;

Candidates who propose this are either assembly language programmers (which is probably good), or else they are closet BASIC/FORTRAN programmers looking to get into a new field.

Data declarations
5. Using the variable a, give definitions for the following:
a) An integer
b) A pointer to an integer
c) A pointer to a pointer to an integer
d) An array of 10 integers
e) An array of 10 pointers to integers
f) A pointer to an array of 10 integers
g) A pointer to a function that takes an integer as an argument and returns an integer
h) An array of ten pointers to functions that take an integer argument and return an integer

The answers are:
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

People often claim that a couple of these are the sorts of thing that one looks up in textbooks-and I agree. While writing this article, I consulted textbooks to ensure the syntax was correct. However, I expect to be asked this question (or something close to it) when I'm being interviewed. Consequently, I make sure I know the answers, at least for the few hours of the interview. Candidates who don't know all the answers (or at least most of them) are simply unprepared for the interview. If they can't be prepared for the interview, what will they be prepared for?

Static
6. What are the uses of the keyword static?

This simple question is rarely answered completely. Static has three distinct uses in C:

A variable declared static within the body of a function maintains its value between function invocations

A variable declared static within a module, (but outside the body of a function) is accessible by all functions within that module. It is not accessible by functions within any other module. That is, it is a localized global

Functions declared static within a module may only be called by other functions within that module. That is, the scope of the function is localized to the module within which it is declared

Most candidates get the first part correct. A reasonable number get the second part correct, while a pitiful number understand the third answer. This is a serious weakness in a candidate, since he obviously doesn't understand the importance and benefits of localizing the scope of both data and code.

Const

7. What does the keyword const mean?

As soon as the interviewee says "const means constant," I know I'm dealing with an amateur. Dan Saks has exhaustively covered const in the last year, such that every reader of ESP should be extremely familiar with what const can and cannot do for you. If you haven't been reading that column, suffice it to say that const means "read-only." Although this answer doesn't really do the subject justice, I'd accept it as a correct answer. (If you want the detailed answer, read Saks' columns-carefully!)

If the candidate gets the answer correct, I'll ask him these supplemental questions:

What do the following declarations mean?

const int a;

int const a;

const int *a;

int * const a;

int const * a const;

The first two mean the same thing, namely a is a const (read-only) integer. The third means a is a pointer to a const integer (that is, the integer isn't modifiable, but the pointer is). The fourth declares a to be a const pointer to an integer (that is, the integer pointed to by a is modifiable, but the pointer is not). The final declaration declares a to be a const pointer to a const integer (that is, neither the integer pointed to by a, nor the pointer itself may be modified). If the candidate correctly answers these questions, I'll be impressed. Incidentally, you might wonder why I put so much emphasis on const, since it is easy to write a correctly functioning program without ever using it. I have several reasons:

The use of const conveys some very useful information to someone reading your code. In effect, declaring a parameter const tells the user about its intended usage. If you spend a lot of time cleaning up the mess left by other people, you'll quickly learn to appreciate this extra piece of information. (Of course, programmers who use const , rarely leave a mess for others to clean up.)

const has the potential for generating tighter code by giving the optimizer some additional information

Code that uses const liberally is inherently protected by the compiler against inadvertent coding constructs that result in parameters being changed that should not be. In short, they tend to have fewer bugs

Volatile
8. What does the keyword volatile mean? Give three different examples of its use.

A volatile variable is one that can change unexpectedly. Consequently, the compiler can make no assumptions about the value of the variable. In particular, the optimizer must be careful to reload the variable every time it is used instead of holding a copy in a register. Examples of volatile variables are:

Hardware registers in peripherals (for example, status registers)

Non-automatic variables referenced within an interrupt service routine

Variables shared by multiple tasks in a multi-threaded application

Candidates who don't know the answer to this question aren't hired. I consider this the most fundamental question that distinguishes between a C programmer and an embedded systems programmer. Embedded folks deal with hardware, interrupts, RTOSes, and the like. All of these require volatile variables. Failure to understand the concept of volatile will lead to disaster.

On the (dubious) assumption that the interviewee gets this question correct, I like to probe a little deeper to see if they really understand the full significance of volatile . In particular, I'll ask them the following additional questions:

Can a parameter be both const and volatile ? Explain.

Can a pointer be volatile ? Explain.

What's wrong with the following function?:

int square(volatile int *ptr)

{

return *ptr * *ptr;

}

The answers are as follows:

Yes. An example is a read-only status register. It is volatile because it can change unexpectedly. It is const because the program should not attempt to modify it

Yes, although this is not very common. An example is when an interrupt service routine modifies a pointer to a buffer

This one is wicked. The intent of the code is to return the square of the value pointed to by *ptr . However, since *ptr points to a volatile parameter, the compiler will generate code that looks something like this:

int square(volatile int *ptr)

{

int a,b;

a = *ptr;

b = *ptr;

return a * b;

}

Because it's possible for the value of *ptr to change unexpectedly, it is possible for a and b to be different. Consequently, this code could return a number that is not a square! The correct way to code this is:

long square(volatile int *ptr)

{

int a;

a = *ptr;

return a * a;

}

Bit manipulation
9. Embedded systems always require the user to manipulate bits in registers or variables. Given an integer variable a, write two code fragments. The first should set bit 3 of a. The second should clear bit 3 of a. In both cases, the remaining bits should be unmodified.

These are the three basic responses to this question:

No idea. The interviewee cannot have done any embedded systems work

Use bit fields. Bit fields are right up there with trigraphs as the most brain-dead portion of C. Bit fields are inherently non-portable across compilers, and as such guarantee that your code is not reusable. I recently had the misfortune to look at a driver written by Infineon for one of their more complex communications chips. It used bit fields and was completely useless because my compiler implemented the bit fields the other way around. The moral: never let a non-embedded person anywhere near a real piece of hardware!

Use #defines and bit masks. This is a highly portable method and is the one that should be used. My optimal solution to this problem would be:

#define BIT3 (0x1 << 3)

static int a;

void set_bit3(void) {

a |= BIT3;

}

void clear_bit3(void) {

a &= ~BIT3;

}

Some people prefer to define a mask together with manifest constants for the set and clear values. This is also acceptable. The element that I'm looking for is the use of manifest constants, together with the |= and &= ~ constructs

Accessing fixed memory locations
10. Embedded systems are often characterized by requiring the programmer to access a specific memory location. On a certain project it is required to set an integer variable at the absolute address 0x67a9 to the value 0xaa55. The compiler is a pure ANSI compiler. Write code to accomplish this task.

This problem tests whether you know that it is legal to typecast an integer to a pointer in order to access an absolute location. The exact syntax varies depending upon one's style. However, I would typically be looking for something like this:

int *ptr;

ptr = (int *)0x67a9;

*ptr = 0xaa55;

A more obscure approach is:

*(int * const)(0x67a9) = 0xaa55;

Even if your taste runs more to the second solution, I suggest the first solution when you are in an interview situation.

Interrupts
11. Interrupts are an important part of embedded systems. Consequently, many compiler vendors offer an extension to standard C to support interrupts. Typically, this new keyword is __interrupt. The following code uses __interrupt to define an interrupt service routine (ISR). Comment on the code.

__interrupt double compute_area

(double

radius)

{

double area = PI * radius *

radius;

printf("\nArea = %f", area);

return area;

}

This function has so much wrong with it, it's hard to know where to start:

ISRs cannot return a value. If you don't understand this, you aren't hired

ISRs cannot be passed parameters. See the first item for your employment prospects if you missed this

On many processors/compilers, floating-point operations are not necessarily re-entrant. In some cases one needs to stack additional registers. In other cases, one simply cannot do floating point in an ISR. Furthermore, given that a general rule of thumb is that ISRs should be short and sweet, one wonders about the wisdom of doing floating-point math here

In a vein similar to the third point, printf() often has problems with reentrancy and performance. If you missed points three and four, I wouldn't be too hard on you. Needless to say, if you got these last two points, your employment prospects are looking better and better

Code examples
12. What does the following code output and why?

void foo(void)

{

unsigned int a = 6;

int b = -20;

(a+b > 6) ? puts("> 6") :

puts("

<

= 6");

}

This question tests whether you understand the integer promotion rules in C-an area that I find is very poorly understood by many developers. Anyway, the answer is that this outputs "> 6." The reason for this is that expressions involving signed and unsigned types have all operands promoted to unsigned types. Thus ?20 becomes a very large positive integer and the expression evaluates to greater than 6. This is a very important point in embedded systems where unsigned data types should be used frequently (see Reference 2). If you get this one wrong, you are perilously close to not getting the job.

13. Comment on the following code fragment.

unsigned int zero = 0;

unsigned int compzero = 0xFFFF;

/*1's complement of zero */

On machines where an int is not 16 bits, this will be incorrect. It should be coded:

unsigned int compzero = ~0;

This question really gets to whether the candidate understands the importance of word length on a computer. In my experience, good embedded programmers are critically aware of the underlying hardware and its limitations, whereas computer programmers tend to dismiss the hardware as a necessary annoyance.

By this stage, candidates are either completely demoralized-or they're on a roll and having a good time. If it's obvious that the candidate isn't very good, then the test is terminated at this point. However, if the candidate is doing well, then I throw in these supplemental questions. These questions are hard, and I expect that only the very best candidates will do well on them. In posing these questions, I'm looking more at the way the candidate tackles the problems, rather than the answers. Anyway, have fun...

Dynamic memory allocation
14. Although not as common as in non-embedded computers, embedded systems do still dynamically allocate memory from the heap. What are the problems with dynamic memory allocation in embedded systems?

Here, I expect the user to mention memory fragmentation, problems with garbage collection, variable execution time, and so on. This topic has been covered extensively in ESP , mainly by P.J. Plauger. His explanations are far more insightful than anything I could offer here, so go and read those back issues! Having lulled the candidate into a sense of false security, I then offer up this tidbit:

What does the following code fragment output and why?

char *ptr;

if ((ptr = (char *)malloc(0)) ==

NULL)

else

puts("Got a null pointer");

puts("Got a valid pointer");

This is a fun question. I stumbled across this only recently when a colleague of mine inadvertently passed a value of 0 to malloc and got back a valid pointer! That is, the above code will output "Got a valid pointer." I use this to start a discussion on whether the interviewee thinks this is the correct thing for the library routine to do. Getting the right answer here is not nearly as important as the way you approach the problem and the rationale for your decision.

Typedef
15. Typedef is frequently used in C to declare synonyms for pre-existing data types. It is also possible to use the preprocessor to do something similar. For instance, consider the following code fragment:

#define dPS struct s *

typedef struct s * tPS;

The intent in both cases is to define dPS and tPS to be pointers to structure s. Which method, if any, is preferred and why?

This is a very subtle question, and anyone who gets it right (for the right reason) is to be congratulated or condemned ("get a life" springs to mind). The answer is the typedef is preferred. Consider the declarations:

dPS p1,p2;

tPS p3,p4;

The first expands to:

struct s * p1, p2;

which defines p1 to be a pointer to the structure and p2 to be an actual structure, which is probably not what you wanted. The second example correctly defines p3 and p4 to be pointers.

Obscure syntax
16. C allows some appalling constructs. Is this construct legal, and if so what does this code do?

int a = 5, b = 7, c;

c = a+++b;

This question is intended to be a lighthearted end to the quiz, as, believe it or not, this is perfectly legal syntax. The question is how does the compiler treat it? Those poor compiler writers actually debated this issue, and came up with the "maximum munch" rule, which stipulates that the compiler should bite off as big (and legal) a chunk as it can. Hence, this code is treated as:

c = a++ + b;

Thus, after this code is executed, a = 6, b = 7, and c = 12.

If you knew the answer, or guessed correctly, well done. If you didn't know the answer then I wouldn't consider this to be a problem. I find the greatest benefit of this question is that it is good for stimulating questions on coding styles, the value of code reviews, and the benefits of using lint.

Well folks, there you have it. That was my version of the C test. I hope you had as much fun taking it as I had writing it. If you think the test is a good test, then by all means use it in your recruitment. Who knows, I may get lucky in a year or two and end up being on the receiving end of my own work.

Nigel Jones is a consultant living in Maryland. When not underwater, he can be found slaving away on a diverse range of embedded projects. He enjoys hearing from readers and can be reached at NAJones@compuserve.com .

References

Jones, Nigel, "In Praise of the #error directive," Embedded Systems Programming, September 1999, p. 114.

Jones, Nigel, " Efficient C Code for Eight-bit MCUs ," Embedded Systems Programming, November 1998, p. 66.

原文地址 http://blog.csdn.net/sailor_8318/archive/2008/03/25/2215041.aspx

Xiao.Zhu 2008-11-28 08:41 发表评论

Xiao.Zhu — Tue, 18 Sep 2007 02:12:00 GMT

Visual Studio 6.0 �~�辑器配色方�?br>
复制以下代码保存�?reg文�g�Q�然后导入注册表�?/p>

--------------------------------------------------------------------------------------------------------------------
Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format]
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Calls Window]
"FontFace"="Fixedsys"
"FontSize"=dword:0000000c
"Text"=hex:00,00,00,00,ff,ff,ff,00,13,01,b3,00
"Text Selection"=hex:ff,ff,ff,00,00,00,00,00,19,00,19,00
"Calls Highlight"=hex:00,00,00,00,00,ff,00,00,10,00,10,00
"Superceded code"=hex:80,80,80,00,ff,ff,ff,00,10,00,10,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Disassembly Window]
"FontFace"="Fixedsys"
"FontSize"=dword:0000000c
"Text"=hex:00,00,00,00,ff,ff,ff,00,13,01,b3,00
"Text Selection"=hex:ff,ff,ff,00,00,00,00,00,19,00,19,00
"Assembly Code"=hex:80,80,80,00,ff,ff,ff,00,10,00,10,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Memory Window]
"FontFace"="Fixedsys"
"FontSize"=dword:0000000c
"Text"=hex:00,00,00,00,ff,ff,ff,00,13,01,b3,00
"Text Selection"=hex:ff,ff,ff,00,00,00,00,00,19,00,19,00
"Memory Highlight"=hex:ff,00,00,00,ff,ff,ff,00,10,00,10,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Output Window]
"FontFace"="FixedSys"
"FontSize"=dword:0000000c
"Text"=hex:c0,c0,c0,00,00,00,00,00,15,00,15,00
"Text Selection"=hex:00,00,00,00,c0,c0,c0,00,19,00,19,00
"Current Error/Tag"=hex:ff,ff,ff,00,00,00,80,00,55,00,55,00
"Bookmark"=hex:00,00,00,00,00,ff,ff,00,10,00,10,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Registers Window]
"FontFace"="Fixedsys"
"FontSize"=dword:0000000c
"Text"=hex:00,00,00,00,ff,ff,ff,00,13,01,b3,00
"Text Selection"=hex:ff,ff,ff,00,00,00,00,00,19,00,19,00
"Value Highlight"=hex:ff,00,00,00,ff,ff,ff,00,10,00,10,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Source Browser]
"FontFace"="DejaVu Sans"
"FontSize"=dword:0000000c
"Text"=hex:c0,c0,c0,00,00,00,00,00,15,00,15,00
"Text Selection"=hex:00,00,00,00,c0,c0,c0,00,19,00,19,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Source Window]
"FontFace"="DejaVu Sans Mono"
"FontSize"=dword:0000000d
"Text"=hex:c0,c0,c0,00,00,00,00,00,12,01,b2,00
"Text Selection"=hex:00,00,00,00,c0,c0,c0,00,19,00,19,00
"Current Error/Tag"=hex:ff,ff,ff,00,00,00,80,00,d2,01,b2,01
"Bookmark"=hex:00,00,00,00,00,ff,ff,00,10,00,10,00
"Breakpoint"=hex:ff,ff,ff,00,80,00,00,00,10,00,10,00
"Current Statement"=hex:00,00,00,00,ff,ff,00,00,70,00,70,00
"Selection Margin"=hex:d4,d0,c8,00,d4,d0,c8,00,13,00,13,00
"Keyword"=hex:ff,00,ff,00,00,00,00,00,10,00,11,00
"Comment"=hex:00,e6,00,00,00,00,00,00,10,00,11,00
"Number"=hex:ff,ff,00,00,00,00,00,00,10,00,11,00
"String"=hex:ff,80,00,00,00,00,00,00,10,00,11,00
"Operator"=hex:c0,c0,c0,00,00,00,00,00,11,00,11,00
"Wizard IDL/ODL Code"=hex:80,80,80,00,00,00,00,00,14,00,15,00
"HTML Element Name"=hex:80,00,80,00,00,00,00,00,14,00,15,00
"HTML Attribute Name"=hex:ff,00,00,00,00,00,00,00,14,00,15,00
"HTML Attribute Value"=hex:00,00,ff,00,00,00,00,00,14,00,15,00
"HTML Comment"=hex:00,80,00,00,00,00,00,00,14,00,15,00
"HTML Entity"=hex:ff,00,00,00,00,00,00,00,14,00,15,00
"HTML Tag Delimiter"=hex:00,00,ff,00,00,00,00,00,14,00,15,00
"HTML String"=hex:00,00,ff,00,00,00,00,00,14,00,15,00
"HTML Tag Text"=hex:ff,00,ff,00,00,00,00,00,14,00,15,00
"HTML Operator"=hex:00,00,ff,00,00,00,00,00,14,00,15,00
"HTML Server-Side Script"=hex:00,00,00,00,ff,ff,00,00,14,00,14,00
"User Defined Keywords"=hex:00,00,ff,00,00,00,00,00,14,00,15,00
"Wizard Code"=hex:80,80,80,00,00,00,00,00,14,00,15,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Variables Window]
"FontFace"="Fixedsys"
"FontSize"=dword:0000000c
"Text"=hex:00,00,00,00,ff,ff,ff,00,13,01,b3,00
"Text Selection"=hex:ff,ff,ff,00,00,00,00,00,19,00,19,00
"Variables Highlight"=hex:ff,00,00,00,ff,ff,ff,00,10,00,10,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Watch Window]
"FontFace"="Fixedsys"
"FontSize"=dword:0000000c
"Text"=hex:00,00,00,00,ff,ff,ff,00,13,01,b3,00
"Text Selection"=hex:ff,ff,ff,00,00,00,00,00,19,00,19,00
"Watch Highlight"=hex:ff,00,00,00,ff,ff,ff,00,10,00,10,00
[HKEY_CURRENT_USER\Software\Microsoft\DevStudio\6.0\Format\Workspace Window]
"FontFace"="Segoe UI"
"FontSize"=dword:0000000c
-----------------------------------------------------------------------------------------------------------------------

Visual Studio 2005
复制以下代码保存�?reg文�g�Q�然后导入注册表�?br>------------------------------------------------------------------------------------------------------------------------
Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\FontAndColors\{A27B4E24-A735-4D1D-B8E7-9716E1E3D8E0}]
"Colorable item format version"=dword:00000008
"FontName"="Courier"
"FontPointSize"=dword:0000000a
"FontCharSet"=dword:00000000
"Plain Text Foreground"=dword:00e5e5e5
"Plain Text Background"=dword:00000000
"Plain Text FontFlags"=dword:00000000
"Selected Text Foreground"=dword:00000000
"Selected Text Background"=dword:00ebe8e7
"Selected Text FontFlags"=dword:80000000
"Line Numbers Foreground"=dword:00804000
"Line Numbers Background"=dword:02000000
"Line Numbers FontFlags"=dword:80000000
"Visible White Space Foreground"=dword:0080ffff
"Visible White Space Background"=dword:02000000
"Visible White Space FontFlags"=dword:80000000
"Collapsible Text Foreground"=dword:00c9c9c9
"Collapsible Text Background"=dword:00000000
"Collapsible Text FontFlags"=dword:00000000
"Comment Foreground"=dword:00c4c4c4
"Comment Background"=dword:001f1f1f
"Comment FontFlags"=dword:00000000
"CSS Property Name Foreground"=dword:0000ffff
"CSS Property Name Background"=dword:02000000
"CSS Property Name FontFlags"=dword:00000000
"CSS Property Value Foreground"=dword:0000ff00
"CSS Property Value Background"=dword:02000000
"CSS Property Value FontFlags"=dword:00000000
"CSS Selector Foreground"=dword:00ffff00
"CSS Selector Background"=dword:02000000
"CSS Selector FontFlags"=dword:00000000
"HTML Attribute Value Foreground"=dword:0000ff00
"HTML Attribute Value Background"=dword:02000000
"HTML Attribute Value FontFlags"=dword:00000000
"HTML Comment Foreground"=dword:0080ff80
"HTML Comment Background"=dword:02000000
"HTML Comment FontFlags"=dword:00000000
"HTML Element Name Foreground"=dword:0000ffff
"HTML Element Name Background"=dword:02000000
"HTML Element Name FontFlags"=dword:00000000
"HTML Entity Foreground"=dword:00ffb66c
"HTML Entity Background"=dword:02000000
"HTML Entity FontFlags"=dword:00000000
"HTML Operator Foreground"=dword:00ffffff
"HTML Operator Background"=dword:02000000
"HTML Operator FontFlags"=dword:00000000
"HTML Server-Side Script Foreground"=dword:00000000
"HTML Server-Side Script Background"=dword:00007777
"HTML Server-Side Script FontFlags"=dword:00000000
"HTML Tag Delimiter Foreground"=dword:00ffff00
"HTML Tag Delimiter Background"=dword:02000000
"HTML Tag Delimiter FontFlags"=dword:00000000
"Identifier Foreground"=dword:00eaeaea
"Identifier Background"=dword:02000000
"Identifier FontFlags"=dword:00000000
"Keyword Foreground"=dword:00ffff00
"Keyword Background"=dword:02000000
"Keyword FontFlags"=dword:00000000
"Number Foreground"=dword:0000a8a8
"Number Background"=dword:02000000
"Number FontFlags"=dword:00000000
"Operator Foreground"=dword:00bf80ff
"Operator Background"=dword:02000000
"Operator FontFlags"=dword:00000000
"Preprocessor Keyword Foreground"=dword:00ff6f6f
"Preprocessor Keyword Background"=dword:02000000
"Preprocessor Keyword FontFlags"=dword:00000000
"Read-Only Region Foreground"=dword:02000000
"Read-Only Region Background"=dword:00c0c0c0
"Read-Only Region FontFlags"=dword:00000000
"Register Data Foreground"=dword:02000000
"Register Data Background"=dword:02000000
"Register Data FontFlags"=dword:00000000
"Register NAT Foreground"=dword:00ffffff
"Register NAT Background"=dword:02000000
"Register NAT FontFlags"=dword:00000000
"String Foreground"=dword:0081c2fe
"String Background"=dword:02000000
"String FontFlags"=dword:00000000
"XML Doc Comment Foreground"=dword:00b7ffb7
"XML Doc Comment Background"=dword:001f1f1f
"XML Doc Comment FontFlags"=dword:00000000
------------------------------------------------------------------------------------------------------------------------

Xiao.Zhu 2007-09-18 10:12 发表评论

Xiao.Zhu — Mon, 13 Aug 2007 01:22:00 GMT

一般全局变量应该用比较长�Q�详�l�的名称�Q�而本地变量则��单明了�ؓ宜�?br>GetSystemMetrics可以获得很多�pȝ��信息�?/p>

�Q�i nclude <>先搜�?I�~�译选项的�\径，然后搜烦环境变量INCLUDE�Q?"先搜索父文�g的�\径，然后才是前面两个路径�?/p>

用C设计一个动态增长的数组�Q�需要用到MALLOC和REALLOC�Q�对与同一个指针，如果内存不够存储数据�Q�就用REALLOC重新分配多一倍的内存。�ƈ且返回的指针不能直接�l�原来的指针�Q�因为如果分配失败，那么原来的数据就会丢失�?/p>

传递函数地址作�ؓ参数

首先定义以函数地址作�ؓ参数的函�?/p>

fun1(�q�回�c�d��(*fun2)(参数))
{
...=(*fun2)(参数);

}
fun2正常定义
调用的时候　　fun1(函数�?;
int fun2(int n)
{
return n+1;

}

int fun1(int n,int(*f)(int b))
{
return (*f)(n);

}
int main(int argc, char* argv[])
{
int a(B),b;
b=fun1(a,fun2);
cout< return 0;
}

实现散列表：使用一个散列函敎ͼ��项散列��C��个数�l�里面，每个数组元素是一个链表，记录�q�个散列值的所有项�?/p>

CMemoryState �c�d��用于��查内存泄霌Ӏ?/p>

构造函数和析构函数都没有返回�?/p>

�cȝ��成员�~�省是私有的.
如果定义了构造函数和析构函数,必须��它们设�|��ؓPUBLIC,否则无法讉K��.
(事实上也可以是private,但只能访问类的静态成�?�q�时不能生成对象,如果要生成对�?需要一定的技�?

重蝲依靠参数不同而不是返回值的不同,因�ؓ我们可以在调用函数的时候忽略返回�?�q�个时候编译器无法��定该调用那个函�?

构造函数可以根据参数类型不同区�?也可以根据参��C��C��同区�?但如果一个构造函数的参数有缺省��D��且前面的参��C��其它构造函数相�?那么如果在调用的时候用��C��~�省�?�~�译器无法分辨该调用那个函数,会报�?

可以在定义函数的时�?让某个参数只有类型名而没有标识符,�q�样做的目的是�ؓ了将来可能需要插入一个参�?在调用的时候随便给�q�个位置一个值就可以�?

int temp(int a,int,int b)
{}

~按位求反

const 存放在符可��?不会被分配内�?如果使用&�W�号,��׃��~�译器�ؓ帔R��分配地址,const数组也会被分配内�?

const int* p�Q�int const* p;指向帔R��的指针，它的内容(*p)不能被改变，也不能将它的��D��int * const p,常指针，��g��变。给非常量指针�?br>对��时对象要使用常值引用接�Ӟ��因�ؓ临时对象是常量�?/p>

对于const成员变量�Q�必��d��构造函数前(构造函数初始化�?对它赋初�?莄onst也可以在�q�里赋�?但没有必�?可以转到构造函��C��?虽然在初始化表里效率更高)。�Q何类型的成员变量都不能在声明的时候赋倹{�?/p>

�c�M��的常量const是对某个具体对象而言的，如果需要对整个�cȝ��常��|��使用enum.

char *p="123456";
cout<<*p++<<*p++;
*p=3;
char *t;
t=p;
输出�l�果�?21,因�ؓ求值顺序是从右到左,�W�三个语句是错的,*p的内存是不可写的,��g��p应该��Z��个常量指�?但确实可以将p赋给一个非常指�?语句5不报�?

如果成员函数被声明�ؓconst,那么其中不能含有改变成员变量值的语句(但可以改变被mutable修饰的成员变�?),也不能调用非const成员函数,如果对象被声明�ؓconst,那么它只能调用const成员函数.

volatile的用法同const,甚至可以使用const volatile做修饰没,volatile标识数据可能被别的进�E�改�?因此有必要在每次使用的时候重读这个数�?�q�在优化期间特别重要,防止�~�译器做一些假�?

�l�宏的参数最好是��单变量，如果不是�Q�如a++,那么变量在宏中出现几�ơ，a��׃��被加多少�ơ。最好不用宏做类似函数的事情�Q�在�c�M��Q�用内联函数代替宏，一样可以得到高效率�?/p>

在类中定义的函数自动成�ؓ内联函数�Q�在�c�d��Q��用inline关键字�?/p>

不应该��用public成员变量�Q�而是应该使用内联函数存取�q�些变量�Q��用重载可以只用一个函数名字完成存取�?/p>

一个程序的所有文�Ӟ��所有的名字�Q�不在函数或�c�M��Q�缺省都是外部连接，�q�意味着不同文�g中相同的名字�Q�不在函数或�c�M��Q�会引�v冲突�Q�如果对�q�些名字用static修饰�Q�就会变成内部连接，名字仅在�~�译单元内可见。extern是static的反义词�Q�表�C�外部连接，同缺省的意义相同。两�U�连接的名字都会存储在静态存储区�?/p>

一旦用于修饰局部变量，static��׃��再表�C�可见性，而只改变变量的存贮类型�?/p>

register表示希望�q�个变量被放在寄存器里，因�ؓ它经常被用到�Q�应该避免��用这个关键字�Q�因��斚w��通常机器比�h更擅�ѝ�?/p>

�c�M��的static变量�Q�包括用static修饰的const�Q�必��d��c�d��函数外的全局位置初始化，初始化的语法是：static �c�d�� c?:变量�?��|��

存在嵌套�c�d��局部类:�c�M��定义的类和函��C��定义的类,后者不能有静态成员变�?昄��Q�没有办法初始化�q�种static变量).

调用c�?在声明的时候要使用extern "C" 函数声明,指明�q�是一个c�q�接.因�ؓc++同c的编译器不同,会�ؓ函数产生不同的内部名,按照c++的方式连接c函数,会找不到库中的函��C��.当然,通常情况下库的开发上已经为我们做好了�q�些.

引用必须被初始化,且引用的对象不能改变.不能引用null.

int f(const int&)
上面是一个常量引�?使用帔R��引用是�ؓ了保证外部变量不被修�?另外,如果传入的是帔R��或者��时对�?不��用常量引用的参数��出�?因�ؓ二者都是常�?

无返回值的函数是void�c�d��.

void inf(int*&i){i++;} 调用:int *i=0; inf(i);
上面的函数是以指针引用做参数,改变指针的�?�q�可以��用指向指针的指针,要麻烦一�?不过表达更明��?void inf(int **i){(*i)++}; 调用�?int *i=0; inf(&i);

通过��g��递给函数�Q�或者函数返回一个对�?是��用位拯��建立对象,�q�种情况下编译器会调用拷贝构造函�?如果没有�~�译器会建立一个缺省的),但对象销毁时会调用析构函�?

如果想禁止通过��g��递某个对�?只要声明一个私有的拯��构造函�?此时�~�译器认为用��h��了�q�项工作,不会建立�~�省的拷贝构造函�?而用户徏立的函数是私有的,没法调用,�~�译器就会报�?

可以定义指向�cȝ��成员变量和成员函数的指针�Q�程序不必��用函数的名字��可以调用它�Q�想起了高通的CDMA�E�序框架.c++�~�程思想�W?0章�?/p>

一个指向函数的指针:
void inf(int *&i){i++;}
int main(int argc, char* argv[])
{
int *i=0;
cout<void (*pf)(int *&);
pf=&inf;
(*pf)(i);
cout<}

�q�算�W�重�?br>重蝲仅是对用��L��型的数据来说的，对内�|�的数据�c�d��是不可以重蝲�q�算�W�的�?br>.�?*都不能重�?可以��运��符重蝲看作另外一�U��Ş式的函数调用�Q�函数的名字是operator@,@代表�q�算�W�，参数的个数取决于两个因素�Q?br>1 �q�算�W�是一元还是二�?br>2 �q�算�W�是全局函数(一元是一个参�?二元是两个参�?,�q�是成员函数(一元没有参�?二元一个参�?---对象变�ؓ左侧参数)

可以重蝲几乎所有的�q�算�W?但对于现在c中没有意义的�q�算�W�是不能重蝲�?也不能改变运��符的参��C��数和优先�U?

重蝲�q�算�W�的�q�回�?如果需要返回对象本�w?�Ҏ��需要返�?br>对象的指针或者引�?如果是返回��时生成的对象,那么�q�回对象.

重蝲�q�算�W�的�q�回值是否常�?当返回的是一个��时值得时�?�?%,&,>>,�q�些�q�算�W�得到的�l�果要赋�l�另外一个变�?�q�时�q�回值是const,如果�q�回值直接用于变�?�?=,+=,�q�是�q�回��g��要加const.

函数�q�回对象的时�?�q�回一个��时对象比新徏一个对象在�q�回效率要高很多,因�ؓ�q�时调用的是普通构造函数而不是拷贝构造函�?而且不需要调用析构函�?虽然新徏一个对象再�q�回�q�回的也是一个��时对�?

��指针(smart pointer):对象,包容�?�q�代�?

自动�c�d��转换:可以�~�程实现自动�c�d��转换.如需要从对象one到two,那么只需要�ؓtwo定义一个以one&为参数的构造函�?当编译器发现需要进行从对象one到two的�{换的时�?会自动检查two的定�?扑ֈ��q�个构造函�?构造一个two对象.如果需要显式类型�{�?在构造函数前加一�?explicit

�q�有一�U�自动类型�{换方法是:为需要�{换的对象重蝲一个运��符,�q�算�W�以要�{换到的对象的名字命名.无须声明�q�回�?
operator one() const{ return one(x);}

不过�q�不提倡隐式类型�{�?�q�样�Ҏ��隐藏错误,也会降低调用时的效率.

使用全局重蝲�q�算�W�而不是成员运��符的好处是可以对左��x��作书都自动作�c�d��转换,而成员运��符的操作数左侧的必��L��正确的对�?/p>

重蝲赋值操作符"=",�q�回可以是引用也可以是�?前者效率较�?但要记得此时�q�回的引用不能是属于局部对象的.通常�q�回*this.

return String(s1+s2); 与String temp(s1+s2);return temp;的效率是不同的，后者要�q�行对象拯��Q�而前者直接将临时对象创徏在函数的�q�回区。同时也更加��z��?/p>

函数中少用static变量。让相同的输入��生相同的输出�Q�这��L��代码便于使用和维护�?/p>

对函数的参数和返回值的有效性进行检查�?/p>

�U�极使用断言(ASSERT),同时要加上注释，防止��来忘记ASSERT的目的�?/p>

之所以有了指针还要引入引用，是�ؓ了对功能加以限制�Q�防止发生意外，��像对参数加上const限定的目的一栗��?/p>

动态分配内存的原则:
1 分配后要��查是否分配成�?即if(p==NULL)
2 释放内存后要记得令p=NULL,防止产生野指�?野指针会让我们在使用指针前的if(p==NULL)��查�Ş同虚�?

要申请一块内存复制数�l�char a[]的内�?应该甌��的内存大��是sizeof(char)*(strlen(a)+1);

如果通过参数传递数�l?数组名自动退化�ؓ一个指�?
main()
{
char a[100];
cout< fun(a);
}
void fun(char a[100])
{
cout<}
输出100 4.

对内存分配失败进行处理有两种�Ҏ��:
1 if(p==NULL) 适用于内存分配语句较��的情况
2 _set_new_handler _set_new_mode 适用于内存分配语句较多的情况

unsigned与没有unsigned �c�d��只是表示范围不同,大小相同.

如果不给�c�d��义拷贝构造函数和赋值函敎ͼ�如果�c�M��有指针变量，��׃��D��错误�Q�如果指针指向动态内存区�Q�那�q�块内存会丢失，而两个指针相同一个块内存�Q�导致其值无法判定，而且两个函数的析构函��C��这块内存释放两�ơ，��D��出错�?br>String a("hello");
String b("world");
String c(a); //调用拯��构造函敎ͼ��q�可以写成：String c=a;但风��D��差�?br>c=a; //调用赋值函�?operator =) 赋值函��C��注意先检查自赋倹{�?/p>

在��承当中，构造函敎ͼ�析构函数�Q�赋值函数都不能被��承，在编写子�c�L��要注以下几点�Q?br>1子类必须在构造函数的初始化表调用基类的构造函数�?br>2父类和子�cȝ��析构函数都必��L��virtual.//用于多态�?br>3子类赋值函数要调用父类的赋值函敎ͼ�Base::operater=(other);

对函数参数和�q�回��D��行const限定仅对指针和引用有意义�Q�对��g��递没有意义，对输出参��C��定不要用const,不然无法输出参数�?/p>

重蝲new和delete的原因有两个�Q�需要反复分配内存，需要亲自做�q�个工作提高效率�Q�还有就是减��内存碎片，比如可以首先使用静态成员指针保留很大一块内�?在静态存储区)�Q�在其中完成内存的分配，�q�自己标记分配和释放�Q�释攄��时候，只是标记内存�Q�而不free释放�?br>重蝲的new和delete只完成内存的分配和回收工作。new接受size_t函数�Q�完成内存的分配�Q�返回一个void*指针�Q�delete接受一个void*指针�Q�将它释放�?br>注意重蝲new和delete有两�U�不同的形式�Q�一个用于每�ơ创��Z��个对象，另一个用来创��Z��个对象数�l�，需要加上[]。如果重载了前者，那么在创建对象数�l�的时候，�pȝ��会调用全局的new和delete.

发现一个有��的现象�Q�可以��用��gؓNULL的指针调用�Q意对象的成员函数�Q�只要先强制转换到这个对象，�q�且调用的是�U�代码�?/p>

成员对象的初始化可以和父�c�L��造函数的调用�q�排攑֜�初始化表�?/p>

在进入构造函数的左括号前�Q�所有的成员变量都必��被初始化�?/p>

构造函敎ͼ�析构函数�Q�赋��D��赋不被�l�承�?/p>

�cȝ��友元能够讉K��其private,protected成员�Q�子�c�能讉K��cȝ��protected成员�?/p>

不要在析构函��C��抛出异常�Q�因为异常处理函数在获得异常后要调用析构函数清理对象�Q�此时再发生异常会导致程序无法再捕获异常�Q�只能终止（只能在自定义的set_terminate()中作最后的处理。）�?/p>

拯��字符串的�Ҏ��
char dest[sz];
memset(dest,0,sz);
strncpy(dest,source,sz-1);
�q�样保证了不会超�q�缓冲区且结��ؓ'\0'.

异常处理函数会首先调用所有在try块中创徏了的对象的析构函敎ͼ�然后执行异常处理函数�Q�然后��l�运行后面的�E�序。但问题是，如果一个析构函数出��C��异常�Q�在析构函数中异常前创徏的堆上的所有对象都无法调用其析构函数正帔R��毁。方法是使用模板�Q��ƈ自初始化表创��些模板对象�?/p>

set_unexpceted可以截获没有被函数异常规��D��明包括得异常�Q�还可以��单的用一个throw;��这个异�怽�为已知异常再�ơ抛出，如果有相应的catch语句�Q�那么就可以捕获�q�个异常�?/p>

抛出异常的子�c�，会被能够捕获其父�c�d��常的处理器捕莗��这时会产生切片�Q�即处理器收到的是一个父�c�，使用引用而不是传递值可以避免这个问题�?br>      try
  {
   throw(except("got it"));
  }
  catch(except &t)
  {
   t.what();
  }

�q�行时类形识别对void指针无效�?/p>

dynamic_cast<>用于向下映射�?br>base* b=new derived;
derived* d=dynamic_castb; 如果dynamic_cast��p�|的话�Q�将�q�回NULL,可以以此来试探着判断指针b的类型�?/p>

RTTI�q�可以��用typeinfo().name()的方法返回对象id。typeinfo()�q�回typeinfo对象�Q��用前要包含头文�gtypeinfo.h.

class B
class D:public B

B* p=new D;
B& r=*p;

typeid(p)==typeid(B*)
typeid(r)!==typeid(D)
typeid(*p)==typeid(D)
typeid(&r)==typeid(B*)

对引用的动态映��也要制定到一个引用上�Q�如果失败不是返回NULL,因�ؓ应用不许为空�Q�而是产生一个异常，因此对引用的动态映��必��M��用异常处理�?/p>

对空指针使用typeid()也会产生异常�Q�可以在使用之前��查指针是否�ؓNULL来避免这个问题�?/p>

在对重��承的情况下，传统的强制类型�{换可能无法正常工作，但动态映��和typeid工作的很好�?/p>

要是动态类型类型�{换，需要基�c�d��含virtual成员函数�Q��ƈ且vc�~�译器有/GR选项。经�q�动态类型�{换，��q��c��{换而来的子�c�L��针可以调用子�c�M��新添加而父�c�M��没有的方法�?/p>

static_cast 通常不是必需的，但它会让�c�d��转换更加醒目�?/p>

const_cast用于��常量和volatile映射�l�普通指针�?/p>

reinterpret_cast是危险�ƈ且可�U�L��性很差的转换�Q�它��对象看作二�q�制数进行�{换。最好不要��用�?/p>

C++中，��结构名直接作�ؓ�c�d��名��用，而不需要象c中那样��用typedef struct �l�构名{} �c�d��?

WINDOWS核心�~�程
内核对象�Q�每个内核对象都是一个内存块�Q�由内核�l�护�Q�进�E�在创徏了一个内核对象后获得一个句柄，通常一个进�E�的句柄对另外一个进�E�是没有意义的，但可以通过一定措施在�q�程间共享内核对象。当�q�程�l�止后，它创建的内核对象不一定消失，内核�l�护每个内核对象的引用计数�?/p>

GDI对象不是内核对象�Q�区分内核对象和GDI对象的方法是内核对象的创建函数的参数中有安全属性，而GDI对象没有�?/p>

内核对象的安全属性通常在创建服务器�E�序的时候用刎ͼ�传递一个NULL可以获得�~�省的安全属性�?/p>

当不再��用某个内核对象的时候，可以使用BOOL CloseHandle(HANDLE)关闭句柄�Q�系�l�会自动��内核对象信息清除出�q�程的句柄表�Q�此句柄表保存且仅保存该�q�程使用的所有内核对象信息。）�Q��ƈ自动为内核对象的引用计数减一。如果忘记关闭句柄也不要紧，在进�E�推出后�Q�系�l�会自动��查进�E�的句柄表，清理没有释放的句柄，因此忘记关闭句不一定会造成内存泄漏�?/p>

�E�序的进入点WinMain的第一个参数时�q�程的实例句柄，也是�q�程映射到虚拟地址�I�间的�v始地址�Q�vc++默认�?x00400000.可以用GetModuleHandle()得到�q�个�?br>PTSTR GetCommandLine()获得命��o�?br>PWSTR CommandLineToArgvW()分解命��o�?/p>

每个�q�程都有一个与他相关的环境块�?br>VarName1=VarValue1\0
VarName2=VarValue2\0
...............
\0

GetEnvironmentVariable() //获得环境变量�?br>ExpandEnvironmentStrings()//展开%包裹的环境变量�?br>SetEnvironmentVariable() //讑֮�环境变量

�q�程的亲�~�性：�q�程的线�E�被��再CPU的子集上�q�行�?/p>

子进�E�默认��承父�q�程的错误标志�?br>SetErrorMode(UINT) //讑֮�错误模式

�q�程�l�护当前驱动器和目录信息
GetCurrentDirectory()
SetCurrentDirectory()

获得�pȝ��版本�Q?br>GetVersion()
GetVersionEx()
VeryfyVersionInfo()

GetExitCodeProcess(),对于�q�在�q�行的进�E�，可以得到0x103�Q�STILL_ACTIVE),对于�l�止的进�E�，如果�q�没有CloseHandle(pi.hProcess),可以得到它的退出码,否则得到的是��q��?/p>

windows2000支持作业��理�Q?通过��进�E�加入作业，可以对进�E�的�q�行权限�Q��用的资源�q�行限制。方法如下：
HANDLE hjob=CreateJobObject(NULL,NULL);//创徏一个作业对象�?br>SetInformationJobObject();//讑֮�作业对象的参敎ͼ�包括对进�E�的各种限制�?br>CreateProcess(NULL,"CMD",NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi);//创徏新进�E��?br>AssignProcessToJobObject(hjob,pi.hProcess); //��进�E�加入作业。可加入多个�?br>ResumeThread(pi.hThread);
CloseHandle(pi.hThread);
HANDLE h[2];
h[0]=pi.hProcess;
h[1]=hjob;
DWORD dw=WaitForMultipleObject(2,h,false,INFINITE);
switch(dw-WAIT_OBJECT_0�Q?br> case 0://the process has terminated..
case 1://all of the job's allotted cpu time was used.
}
CloseHandle(pi.hProcess);
CloseHandle(hjob);

�l�止作业中所有进�E�的�q�行
TerminateJobObject(hjob,UINT uExitCode)

查询作业�l�计信息
QueryInformationJobObject();

监视作业的运行：
JOBOBJECT_ASSOCIATE_COMPLETION_PORT joacp;//创徏一个I/O完成端口对象
SetInformationJobObject(hjob.JobObjectAssociateCompletionPortInformation,&joacp,sizeof(joacp)
//��作业同完成端口对相兌��?br>GetQueuedCompletionStatus() //监控I/O端口�?/p>

�q�程�׃��部分�l�成�Q�进�E�内核对象，地址�I�间。进�E�是不活泼的�Q�它的执行依赖于�U�程�?br>�U�程�׃��部分�l�成�Q�线�E�内核对象，�U�程堆栈�?/p>

创徏新线�E�：
DWORD　WINAPI FUNC(PVOID pvParam)
int Param;
DWORD dwThreadID;
CreateThread(NULL,0,FUNC,(PVOID)&Param,0,&dwThreadID);

��查线�E�是否退出：
BOOL GetExitCodeThread(HANDLE hThread,PDWORD pdwExitCode);//如果�q�未�l�止�Q�得�?x103.

获得伪句柄：
GetCurrentProcess()
GetCurrentThread()

获得�q�行旉��Q?br>GetProcessTimes()
GetThreadTimes()

�U�程或进�E�的伪句柄�{化�ؓ实句柄：
DuplicatgeHandle();//此函��C��增加内核对象的引用计数�?/p>

伪句柄用于本�U�程�Q�获得这个句�q�不会媄响内核对象的计数�Q�而实句柄用于传递给子进�E��?/p>

�U�程的暂停和�q�行�Q?br>ResumeThread(HANDLE)
SuspendThread(HANDLE) //使用此函数要��心死锁�?/p>

�U�程休眠�Q?br>Sleep(DWORD dwMilliseconds);
自动退出当前时间片�Q?br>SwitchtoThread();

可以获得和修改线�E�的上下文，使用之前要SuspendThread()
GetThreadContext()
SetThreadContext()

改变�q�程的优先��://��C��q�程是不可以调度的，调度的单位是�U�程�?br>BOOL　SetPriorityClass();
DWORD GetPriorityClass();

讑֮��U�程的相对优先��Q?br>int GetThreadPriority(HANDLE hThread);
BOOL SetThreadPriority(Handle hThread,int nPriority);

Microsoft保留了随时修改调度算法的权利�Q�因此��用相对优先��Q�可以保证程序在��来的系�l�上也可以正常运行�?br>�l�合�q�程优先�U�和�U�程的相对优先��Q�就可以得到�U�程的基本优先��。线�E�的当前优先�U�不可以低于基本优先�U�，
也就是说�Q�系�l�会提高�U�程的优先��Q��ƈ随着执行旉��片的��逝降低优先��Q�但降到基本优先�U�后��׃��再降了�?br>优先�U?-15成�ؓ动态优先��范围�Q�高�?5是实时范��_��pȝ��不会调度实时范围�U�程的优先��Q�也不会把动态优先��范围�?br>�U�程提高�?5以上�?/p>

亲缘性是对多处理器系�l�来说的�Q��ؓ了能利用保留在cpu高速缓存和NUMA(非统一内存讉K��Q�结构计��机本插件板上内存中的数据，�pȝ��量�U�程上次�q�行使用的CPU来运行线�E�，包括软亲�~�性（WIN2000默认�Q�和��亲�~�性（用户可以选择CPU)
相关的函数有�Q?br>BOOL SetProcessAffinityMask(HANDLE hProcess,DWORD_PTR dwProcessAffinityMask);
BOOL GetProcessAffinityMask(Handle hProcess,PDWORD_PTR pdwProcessAffinityMask,PDWORD_PTR pdwSystemAffinityMask);
DWORD_PTR SetThreadAffinityMask(HANDLE hThread,DWORD_PTR dwThreadAffinityMask);
DWORD_PTR SetThreadIdealProcessor(HANDLE hThread,DWORD dwIdealProcessor);

临界��Z��证其中的资源�Q�通常是各�U�共享变量）被原子的讉K��Q�当�q�入临界区后�Q�其他访问这些资源的�U�程��不会被调度�?/p>

�U�程同步包括用户方式和内核方式，用户方式包括原子操作和��界区�Q�它的特�Ҏ��速度快，但功能有限。内核方式利用内核对象的通知状态来同步�U�程�Q�由于需要由用户方式切换到内核方式（�q�种切换很废旉��Q�，且系�l�要�q�行很多操作�Q�效率较低，但功能强大（能够讑֮��时值等,可以同步多个�q�程的线�E�）�?/p>

内核方式同步的原理：�U�程使自��p��入休眠状态，�{�待内核对象由未通知状态变为已通知状态�?/p>

可处于未通知状态变和已通知状态的内核对象�Q�进�E�，�U�程�Q�作业，文�g修改通知�Q�时��_��可等待定时器�Q�文�Ӟ��控制台输入，信号量，互斥体�?/p>

�q�程和线�E�在建立时处于未通知状态，在退出时变�ؓ已通知状态�?/p>

�{�待函数�Q?br>DWORD WaitForSingleObject(HANDLE hObject,DWORD dwMilliseconds);
DWORD WaitForMultipleObject(DWORD dwCount,CONST HANDLE* phObjects,BOOL fWaitALL,DWORD dwMilliseconds);其中�Q?br>0�q�回值的含义�Q?br>HANDLE h[3];
h[0]=hProcess1;
h[1]=hProcess2;
h[2]=hProcess3;
DWORD dw=WaitForMultipleObject(3,h,FALSE,5000);
switch(dw)
{
    case WAIT_FAILED://Bad call to function(invalid handle?)
         break;
    case WAIT_TIMEOUT�Q?/None of the object became signaled within 5000 milliseconds.
         break;
    case WAIT_OBJECT_0+0:The process identified by h[0] terminated.
         break;
    case WAIT_OBJECT_0+1:
         break;
    case WAIT_OBJECT_0+2:
         break;
}
//WaitForSingleObject()的返回值只有前三种情况。如果给WaitForMutipleObject()的fWaitAll参数传递TRUE,那么其返回��g��只有前三�U��?/p>

事�g内核对象�Q�有两种�Q��h工事件对象：当它得到通知的时候，所有等待的�U�程都变为可调度�U�程�Q�自动重�|�的事�g�Q�当事�g得到通知的时候，只有一个等待线�E�变为可调度的线�E�。创��Z��件内核对象：
HANDLE CreateEvent(PSECURITY_ATTRIBUTES psa,BOOL fManualReset,BOOL fInitialState,PCTSTR pszName);
��事件改为通知状态：
BOOL SetEvent(HANDLE hEvent);
��事件改为未通知状态：
BOOL ResetEvent(HANDLE hEvent);
如果事�g是自动重�|�事�Ӟ��那么成功�{�待会��生副作用�Q�即��事件自动置为未通知状态。如果是人工事�g对象�Q�则没有副作用�?/p>

�{�待定时器内核对象：是在某个旉��或按规定的间隔时间发��q��信号通知的内核对象�?br>HANDLE CreateWaitableTimer(PSECURITY_ATTRIBUTES psa,BOOL fManualReset,PCSTR pszName);
初始��L��未通知状态�?br>BOOL SetWaitableTimer(
HANDLE hTimer,
const LARGE_INTEGER *pDueTime,
LONG lPeriod,
PTIMERAPCROUTINE pfnCompletionRoutine,
PVOID pvArgToCompletionRoutine,
BOOL fResume);
取消定时器：
BOOL CancelWaitableTimer(HANDLE hTimer);
如果仅想改变报时条�g�Q�不用调用这个函数暂停报时器�Q�直接调用SetWaitableTimer()��可以了�?/p>

信号量内核对�?br>如果当前资源的数量大�?�Q�发��Z��?br>如果当前资源数量�{�于0�Q�不发出信号
决不允许资源数量��倹{�?br>创徏信号量：
HANDLE CreateSemaphore(PSECURITY_ATTRIBUTE psa,
LONG lInitialCount,
LONG lMaximumCount,
PCSTR pszName);
递增资源�Q?br>BOOL ReleaseSemaphore(HANDLE hsem,
LONG lReleaseCount,
PLONG plPreviousCount);

互斥体内核对象：互斥体确保对单个资源的互斥访问。它包含一个��用数量，一个线�E�ID,一个递归计数�?br>与��界区的区别：能够同步多个�q�程中的�U�程�Q�可以设定超时倹{�?br>如果ID�?�Q�那么表�C�没有线�E�占用互斥体�Q�互斥体发出信号�?br>如果ID不�ؓ0�Q�表�C�占用资源的�U�程ID�Q�不发出信号�?/p>

HANDLE CreateMutex(PSECURITY_ATTRIBUTES psa,
BOOL fInitialOwner,
PCTSTR　pszName);

释放资源�Q?br>BOOL ReleaseMutex(HANDLE hMutex);

额外的函敎ͼ�
DWORD SingalObjectAndWait(
HANDLE hObjectToSignal,
HANDLE hObjectToWaitOn,
DWORD dwMilliseconds,
BOOL fAlertable);
发出一个通知信号�q�等待另一个通知�Q�效率比分别操作提高很多�?/p>

windows2000提供了如下几�U�线�E�池函数用于�U�程��理�Q?br>一、异步调用函�?
BOOL QueueUserWorkItem(
PTHREAD_START_ROUTINE pfnCallback,
PVOID pvContext�Q?br>ULONG dwFlags);
该函数将“工作��目”攑օ��U�程池�ƈ且立卌��回。工作项目是指一个用pfnCallback参数标识的函数。它被调用�ƈ且传递单个参数pvContext.工作��目函数原型如下�Q?br>DWORD WINAPI WorkItemFunc(PVOID pvContext);
dwFlags参数�Q�WT_EXECUTEDEFAULT 工作��目攑օ�非I/O�l��g得线�E�中
WT_EXECUTEINIOTHREAD 工作��目攑օ�I/O�l��g的线�E�中�Q�这��L��U�程在I/O��h��没有完成之前不会被终止运�?nbsp; �Q�防止因为线�E�被�l�止��D��I/O��h��丢失�?br> WT_EXECUTEINPERSISTENTTHREAD 攑օ��怹��U�程池，
WT_EXECUTELONGFUNCTION 工作��目需要长旉��的工作，�pȝ��会据此安排更多的�U�程�?/p>

�U�程池不能设�|�线�E�个数的上限�Q�否则排队个数超�q�线�E�个��C��限的时候，会导致所有的�U�程都被中断�?/p>

工作��目函数如果讉K��了已�l�被卸蝲的DLL,会��生违规访问�?/p>

二、按规定的时间间隔调用函�?br>创徏定时器队列：
HANDLE CreateTimerQueue();
在队列中创徏定时器：
BOOL CreateTimerQueueTimer(
PHANDLE phNewTimer,
HANDLE hTimerQueue,
WAITORTIMERCALLBACK pfnCallback,
PVOID pvContext,
DWORD dwDueTime,
DWORD dwPeriod,
ULONG dwFlags);
工作回调函数原型如下�Q?br>VOID WINAPI WaitOrTimerCallback(
PVOID pvContext,
BOOL fTimerOrWaitFired);
dwFlags比前面的多了一个标志：WT_EXECUTEINTIMERTHREAD,表示��q��件的定时器线�E�（定时器组件只有一个线�E�）�q�行�q�个
工作函数�Q�此时的工作函数必须是很快返回的�Q�否则定时器�l��g��无法处理其他的��h��?/p>

删除定时器：
BOOL DeleteTimerQueueTimer(
HANDLE hTimerQueue,
HANDLE hTimer,
HANDLE hCompletionEvent);
在定时器�U�程中删除定时器会造成死锁。设定hCompletionEvent为INVALID_HANDLE_VALUE�Q�那么在定时器的所有排队工作项目没有完成之前，DeleteTimerQueueTimer不会�q�回�Q�也��是说在工作��目中对定时器进行中断删除会死锁。可以给hCompletionEvent传递事件句柄，函数会立卌��回，在排队工作完成之后，会设�|�该事�g�?/p>

重新讑֮�定时器：//不能修改已经触发的单步定时器�?br>BOOL ChangeTimerQueueTimer(
HANDLE hTimerQueue,
HANDLE hTimer,
ULONG dwDueTime,
ULONG dwPeriod;

删除定时器队列：
BOOL DeleteTimerQueueEx(
HANDLE hTimerQueue,
HANDLE hCompletionEvent);

三、当单个内核对象变�ؓ已通知状态时调用函数
BOOL RegisterWaitForSIngleObject(
PHANDLE phNewWaitObject,
HANDLE hObject,
WAITORTIMERCALLBACK pfnCallback,
PVOID pvContext,
ULONG dwMilliseconds,
ULONG dwFlags);
pfnCallBack原型�Q?br>VOID WINAPI WaitOrTimerCallbadkFunc(
PVOID pvContext,
BOOLEAN fTimerorWaitFired);
如果�{�待��时�Q�fTimerorWaitFired==TRUE,如果是已通知状态，则�ؓFALSE.

dwFlags可以传递参敎ͼ�WT_EXECUTEINWAITTHREAD,它让�{�待�l��g得线�E�之一�q�行工作��目函数。注意项同前�?/p>

如果�{�待的内核对象是自动重置的，那么会导致工作函数被反复调用�Q�传递WT_EXECUTEONLYONCE会避免这�U�情��c�?/p>

取消�{�待�l��g的注册状态：
BOOL UnregisterWaitEx(
HANDLE hWaitHandle,
HANDLE hCompletionEvent);

四、当异步I/O��h��完成时调用函�?br>��设备和�U�程池的非I/O�l��g兌��
BOOL BindIoCompletionCallback(
HANDLE hDevice,
POVERLAPPED_COMPLETION_ROUTINE pfnCallback,
ULONG dwFlags//始终�?);

工作函数原型�Q?br>VOID WINAPI OverlappedCompletionRoutine(
DWORD dwErrorCode,
DWORD dwNumberOfBytesTransferred,
,
POVERLAPPED pOverlapped);

Windows的内存结�?/p>

�?8�Q?000�Q�到64位的windows,内存��理方式都是不同的，32位的win2000用户内存是从0x10000�?x7fffffff�Q?4kB-2G),2000 Advanced server可以辑ֈ��Q?4kB-3G),其中最�?4kB也是��止�q�入的。再往上则��q��l��用�?8则是�?x400000-0x7fffffff(4M-2G),2G-3G是系�l�用来存�?2位共享数据的地方�Q�如很多�pȝ��动态连接库�?-4M是�ؓ了兼�?6位程序保留的�?G-4G��q��l�自�w��用�?8的内核区是不受保护的�Q?000受保护�?br>对虚拟地址�I�间的分配称作保留，使用虚拟内存分配函数(VirtualAlloc),释放使用VirtualFree(),目前�Q�所有cpu�q�_��的分配粒度都�?4kB,��面大小则不同，x86�?kB,Alpha�?kB,�pȝ��在保留内存的时候规定要从分配粒度边界开始，�q�且是页面的整数倍，用户使用VirtualAlloc都遵守这个规定，但系�l�不是，它是从页面边界开始分配的�?/p>

��物理存储器映射��C��留的内存区域的过�E�称为提交物理存储器�Q�提交是以页面�ؓ单位�q�行的，也��用VirtualAlloc函数�?/p>

物理存储器是由内存和�Q�硬盘上的）��|��件组成的�Q�如果访问的数据是在��|��件中�Q�则�U�Cؓ��面失效�Q�cpu会把讉K��通知操作�pȝ��Q�操作系�l�负责将数据调入内存�Q��ƈ指导cpu再次�q�行上次失效的指令�?/p>

当启动一个程序的时候，�pȝ��q�不是将整个文�g��d��内存或者页文�g�Q�而是��这个文件直接映��到虚拟内存�I�间�Q��ƈ��需要的数据��d��内存�Q�即��硬盘上的文件本�w�当作页文�g�Q�虽然不是）。当��盘上的一个程序的文�g映像�Q�这是个exe文�g或者dll文�g�Q�用作地址�I�间的物理存储器�Q�它�U�Cؓ内存映射文�g。当一�?exe或者dll文�g被加载时�Q�系�l�将自动保留一个地址�I�间的区域，�q�将该文件映��到该区域中。但�pȝ��也提供了一�l�函敎ͼ�用于��数据文件映��到一个地址�I�间的区域中�?/p>

物理存储器的��面��h��不同的保护属性：
PAGE_NOACESS
PAGE_READONLY
PAGE_READWRITE
PAGE_EXECUTE
PAGE_EXECUTE_READ
PAGE_EXECUTE_READWRITE
PAGE_WRITECOPY
PAGE_EXECUTE_WRITECOPY
后两个属性是配合�׃�n��面机制使用的。WINDOWS支持多个�q�程�׃�n单个内存块，比如�q�行notepad�?0个实例，可以让他们共享应用程序的代码和数据，�q�样可以大大提高性能�Q�但要求该内存块是不可写的。于是系�l�在调入.exe或者dll的时候，会计��那些页面是可以写入的，��些页面分配虚拟内存。然后同其他的页面一��h��到一块虚拟内存，但赋PAGE_WRITECOPY或者PAGE_EXECUTE_WRITECOPY属�?通常包含代码的块是PAGE_EXECUTE_READ�Q�包含数据的块是PAGE_READWRITE)。当一个进�E�试囑ְ�数据写入�׃�n内存块时�Q�系�l�会�q�行如下操作�Q�寻��N��先分配的一个空闲页面，��试图修改的��面拯��到这个空闲页面，赋予PAGE_READWRITE或者PAGE_EXECUTE_READWRITE属性，然后更新�q�程的页面表�Q��得用户可以对新的��面�q�行写入�?/p>

�q�有三个�Ҏ��的保护属性：PAGE_NOCACHE PAGE_WRITECOMBINE PAGE_GUARD,前两个用于驱动程序开发，最后一个可以让应用�E�序在页面被写入的时候获得一个异常�?/p>

块的意思是一�l�相�ȝ��面�Q�它们具有相同的保护属性，�q�且受相同类型的物理存储器支持�?br>赋予虚拟内存��面保护属性的意义是�ؓ了提高效率，而且�q�个属性��M��被物理存储器的保护属性取代�?/p>

如果数据在内存中没有寚w��Q�那么cpu要多�ơ访问才能得到数据，效率很低�?/p>

内存��理函数�Q?/p>

获得�pȝ��信息�Q?br>VOID GetSystemInfo(LPSYSTEM_INFO psinf);//可以得到��面大小�Q�分配粒度，最大内存地址�Q�最��内存地址�?/p>

获得内存状态：
VOID GlobalMemoryStatus(LPMEMORYSTATUS pmst);

获得内存地址的某些信息：
DWORD VirtualQuery(
LPVOID pvAddress,
PMEMORY_BASIC_INFORMATION pmbi,
DWORD dwLength);

DWORD VirtualQuery(
HANDLE hProcess,
LPVOID pvAddress,
PMEMORY_BASIC_INFORMATION pmbi,
DWORD dwLength);

内存映射文�g的优点：
1 节省��面文�g;
2 加快�E�序启动�Q?br>3 在多个进�E�间�׃�n数据�?/p>

�q�程的启动过�E�：
�pȝ��首先��?exe文�g映射到地址�I�间�Q�缺省基地址�?x400000,然后查询.exe的输入表�Q�将其��用的所�?dll也映��到地址�I�间�Q�基地址在每�?dll文�g中，如果不能满��Q�需要重定位�Q�，然后��执�?exe的启动代码。此�?exe文�g�q�在��盘上。每�ơ代码蟩��C��个尚未加载到内存的指令地址�Q�就会出��C��个错误，�pȝ��会发现这个错误，�q�将代码加再到内存中�?br>如果再创��?exe文�g的一个实例。那么直接将原来的地址�I�间中的内容映射到新的地址�I�间��可以了。这样多个实例就可以�׃�n相同的代码和数据。如果某个实例要改变�׃�n内容�Q�系�l�就��更改的页面申请一个新的页面，��内�Ҏ��贝一份，然后用新的页面代替地址�I�间中原来页面的映射��可以了�?8�?000不同�Q�它不待修改便立即�ؓ所有的实例分配新的��面�?/p>

使用内存映射文�g�Q?br>1 创徏或打开一个文件内核对象：
HANDLE CreateFile(
PCSTR pszFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
PSECURITY_ATTRIBUTES psa,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile);
��p�|的返回值是INVALID_HANDLE_VALUE
2 创徏一个文件映��内核对象：
HANDLE CreateFileMapping(
HANDLE hFile,
PSECURITY_ATTRIBUTES psa,
DWORD fdwProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
PCTSTR pszName);
如果�l�函数的fdwProtect传递PAGE_READWRITE标志�Q�那么磁盘上文�g的大��会变�ؓ同映像文件相同大��?br>��p�|的返回值是NULL�?/p>

3 ��文件映��到�q�程的地址�I�间�Q?br>PVOID MapViewOfFile(
HANDLE hFileMappingObject,
DWORD dwDesiredAccess,
DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow,
SIZE_T dwNumberOfBytesToMap);
windows2000会根据要求将部分文�g映射到地址�I�间�Q�而win98��L��把全部内�Ҏ��到地址�I�间�Q��ƈ且仅能映��到2G-3G�I�间�Q�此�I�间为共享空��_��所有的�q�程如果映射相同的文�Ӟ��那么都会映射到相同的地址�Q�一个进�E�甚至不必映��就可以讉K��q�个�I�间里其他进�E�的映射文�g�Q�win2000多个�q�程映射同一个文件返回的地址通常是不同的�?br>4 从进�E�的地址�I�间中撤销文�g数句的映�?br>BOOL UnmapViewOfFile(PVOID pvBaseAddress);

��文件映像写入磁盘：
BOOL FlushViewOfFile(
PVOID pvAddress,
SIZE_T dwNumberOfBytesToFlush);

windows保证单个文�g映射对象的多个视囑օ�有相��x��。但不保证但个文件的多个映射对象有相��x��?/p>

使用MapViewOfFileEx代替MapViewOfFile可以讑֮�文�g映射的基地址�Q?br>PVOID MapViewOfFileEx(
HANDLE hFileMappingObject,
DWORD dwDesiredAccess,
DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow,
SIZE_T dwNumberOfBytesToMap,
PVOID pvBaseAddress);

使用内存映射文�g在进�E�间�׃�n数据
�׃�n机制�Q�RPC ,COM,OLE,DDE,�H�口消息�Q�WM_COPYDATA),剪脓板，邮箱�Q�管道，套接字�?br>在单��Z��Q�它们的底层实现�Ҏ��都是内存映射文�g�?/p>

可以在页文�g中直接创建文件映��对象，�Ҏ��是给CreateFileMapping函数的hFile参数传逺�NVALID_HANDLE_VALUE.注意�Q?br>CreateFile()函数�q�行��p�|也会�q�回�q�个参数�Q�因此一定要��查CreateFile�Q�）的返回倹{��记住，文�g函数�q�行��p�|的可能性太大了�?/p>

�W�三章：多个�q�程�׃�n对象�?/p>

堆栈�Q�优点：可以不考虑分配�_�度和页面边界之�cȝ��问题�Q�集中精力处理手头的��d��Q�缺�Ҏ��Q�分配和释放内存块的速度比其他机制慢�Q��ƈ且无法直接控制物理存储器的提交和回收�?/p>

�q�程的默认堆栈是1MB,可以使用/HEAP链接开兌��整大��，DLL没有相关的堆栈�?/p>

堆栈的问题在于：很多windows函数要��用��时内存块�Q�进�E�的多个�U�程要分配内存块�Q�这些内存都是在默认堆栈上分配的�Q�但规定旉��内，每次只能�׃��个线�E�能够分配和释放默认堆栈的内存块�Q�其他想要处理内存块的线�E�必��ȝ��待。这�U�方法对速度又媄响。可以�ؓ�q�程的线�E�创��助堆栈，但windows函数只能使用默认堆栈�?/p>

获取�q�程默认堆栈句柄�Q?br>HANDLE GetProcessHeap();

创徏辅助堆栈的理�?br>1 保护�l��g�Q?br>多个�l��g的数据�؜合交叉的存放在一块内存里�Q�那么一个组件的错误操作很容易媄响到另外一个组件。而要定位错误的来源将十分困难�?br>2 更有效的内存��理
通过在堆栈中分配同样大小的对象，可以更加有效的管理内存，减少内存��片�?br>3 �q�行本地讉K��Q?br>��同�U�数据集中到一定的内存块，可以在操作的时候访问较��的��面�Q�这��减��了RAM和硬盘对换的可能.
4 减少�U�程同步的开销�Q?br>通过告诉�pȝ��只有一个线�E��用堆�?创徏堆栈时��用HEAP_NO_SERIALIZE标志�l�fdwOptions)�Q�可以避免堆栈函数执行额外的用于保证堆栈安全性的代码�Q�提高效率，但此时用户必��自��q��护线�E�的安全性，�pȝ��不再�Ҏ��负责�?br>5 �q�速释攑֠�栈�?br>因�ؓ数据单一�Q�因此释攄��时候只要释攑֠�栈即可，不必昄��的释放每个内存块�?/p>

创徏辅助堆栈�Q?br>HANDLE HeapCreate(
DWORD fdwOptions,
SIZE_T dwInitialSize,
SIZE_T dwMaximumSize);

从堆栈中分配内存�Q?br>PVOID HeapAlloc(
HANDLE hHeap,
DWORD fdwFlags,
SIZE_T dwBytes);注意�Q�当分配��过�Q?MB)内存块的时候，最好��用VirtualAlloc�Q�）�Q?/p>

改变内存块的大小�Q?br>PVOID HeapReAlloc(
HANDLE hHeap,
DWORD fdwFlags,
PVOID pvMem,
SIZE_T　dwBytes);

��索内存块的大��：
SIZE_T HeapSize(
HANDLE hHeap,
DWORD fdwFlags,
LPVOID pvMem);

释放内存�?
BOOL HeapFree(
HANDLE hHeap,
DWORD fdwFlags,
PVOID pvMem);

撤销堆栈�Q?br>BOOL HeapDestroy(HANDLE hHeap);

使用辅助堆栈的方法：重蝲对象的new操作�W�，在辅助堆上分配内存，�q�给对象��d��一个静态变量用于保存堆句柄�?/p>

其它堆栈函数�Q?br>获取�q�程中所有堆栈得句柄�Q?br>DWORD GetProcessHeaps(DWORD dwNumHeaps,PHANDLE pHeaps);
验证堆栈完整性：
BOOL HeapValidate(
HANDLE hHeap,
DWORD fdwFlags,
LPCVOID pvMem);
合�ƈ地址中的�I�闲�?br>UINT HeapCompact(
HANDLE hHeap�Q?br>DWORD fdwFlags);

BOOL HeapLock(HANDLE hHeap);
BOOL HeapUnlock(HANDLE

遍历堆栈�Q?br>BOOL HeapWalk(
HANDLE hHeap,
PProcess_HEAP_ENTRY pHeapEntry);

各个dll也可以有自己的输入表�?/p>

如何�~�写DLL:
在DLL的头文�g中，有如下代码：
#ifdef MYLIB
#else
#define MYLIB extern "C" __declspec(dllimport)
#endif
在每个输出变量和输出函数的声明前�Q�用MYLIB修饰�?br>在DLL的实现文件中�Q�有如下代码�Q?br>�Q�i nclude "windows.h"
#define MYLIB extern "C" __declspec(dllexport)
�Q�i nclude "Mylib.h"

其它的同�~�写普通C++�E�序完全相同�?"C" 表示按C方式链接和调用函数。C++�~�译器缺省按照__stdcall方式�~�译和调用，�q�种方式会改变函数的内部名字。此处如果把"C"都去掉也可以�Q�但C�E�序��无法调用。另外，使用GetProcAddress函数时也会发生困难，因�ؓ
�~�译�E�序已经把函数名字改变了�Q�无法用原来的名字得到函数地址。（核心�~�程说的不明白，没想到这本书错误�q�么多）
发行的时候，��头文�g�?lib文�g和DLL文�g�l�用户就可以了。lib文�g的作用是说明了头文�g中函数所在的DLL文�g�Q�如果没有lib文�g�Q�编译器��在链接�q�程中提�C�错误：unresolved external symbol 函数名�?br>事实上，调用DLL有两�U�方式，�W�一�U�是比较常用�Q�即包含DLL的头文�g�Q��ƈ在链接的时候将动态链接库同exe文�g像连接，建立输入表。这个时候需�?lib文�g。第二种�Ҏ��exe文�g中没有输入表�Q�程序��用LoadLibrary(Ex)和GetProcAddress()昑ּ�的加载DLL文�g�Q�卸载用FreeLibrary())�Q�这个时候不需�?lib文�g�?br>HINSTANCE LoadLibrary(PCTSTR pszDLLpathName);
HINSTANCE LoadLibraryEx(PCTSTR pszDLLpathName,NULL,0);

两次调用LoardLibrary�q�不会装载两�ơdll文�g�Q�只是将dll映射�q�进�E�的地址�I�间。系�l�会自动为每个进�E�维护一个dll的计数。FreeLiabray会��计数减一�Q�如果计��Cؓ0�Q�系�l�就会将dll从进�E�的地址�I�间卸蝲�?/p>

HINSTANCE GetModuleHandle(PCTSTR pszModuleName);//��定dll是否已经被映��进地址�I�间�?br>HINSTANCE hinstDll=GetModuleHandle("MyLib");
if(hinstDll==NULL)
{
hinstDll=LoadLibrary("MyLib");
}

DWORD GetModuleFileName(
    HINSTANCE hinstModule,
    PTSTR pszPathName,
    DWORD cchPath
}
可以获得某个模块�Q?exe或者dll)的全路径名�?/p>

几个函数的用法：�Q�注意GetProcAddress()函数的用法，如何定义和��用一个函数指针）
typedef int (*MYPROC)(int,int);

int main()
{
HINSTANCE t;
t=LoadLibraryEx(TEXT("tt.dll"),NULL,0);
if(t)
{
cout<

}
HINSTANCE hinstDll=GetModuleHandle("tt.dll");
if(hinstDll==NULL)
{
  cout<  hinstDll=LoadLibrary("MyLib");
}
size_t sz=100;
PTCHAR str=new TCHAR[sz];
GetModuleFileName(t,str,sz);
cout< delete str;
MYPROC add=NULL;
add=(MYPROC)GetProcAddress(t,"add");
    if(NULL!=add)
    {
  cout<<(*add)(1,2)< }
FreeLibrary(t);

return 0;
}

UNICODE
ANSI/UNICODE通用的定义方法（转换只需要在�~�译的时候��用_UNICODE和UNICODE�Q�：
TCHAR _TEXT("success") PTSTR PCTSTR _tcscpy(),_tcscat();
使用BYTE PBYTE定义字节�Q�字节指针和数据�~�冲�?br>传递给函数的缓存大��：sizeof(szBuffer)/sizeof(TCHAR)
�l�字�W�串分配内存�Q�malloc(nCharacters*sizeof(TCHAR));
其它的字�W�串函数�Q?br>PTSTR CharLower(PTSTR pszString);
PTSTR CharUpper(PTSTR pszString);
转换单个字符�Q?br>TCHAR c=CharLower((PTSTR)szString[0]);
转换�~�存中的字符�Ԍ��不必�?�l�尾�Q�：
DWORD CharLowerBuff(
PTSTR pszString,
DWORD cchString);
DWORD CharUpperBuff(
PTSTR pszString,
DWORD cchString);

BOOL IsCharAlpha(TCHAR ch);
BOOL IsCharAlpahNumeric(TCHAR ch);
BOOL IsCharLower(TCHAR ch);
BOOL IsCharUpper(TCHAR ch);

�U�程本地存储(TLS):��E�的每个�U�程存储�U�有数据。用于那些一�ơ传递参数后多次调用的函敎ͼ�函数会保存上�ơ调用的数据�Q��?br>实现�Ҏ��Q�进�E�中有一个位标志树组�Q�win2000的这个数�l�大��超�q?000�Q�。在每个�U�程中有一个对应的PVOID数组。通过讑֮�位标志树�l�的某个位来分配每个�U�程中的PVOID数组得相应单元。函数需要每�ơ检索线�E�的PVOID数组�Q�获得该�U�程的相应数据�?/p>

DWORD TlsAlloc(); //为每个线�E�分配一个空的PVOID数组单元�?/p>

BOOL TlsSetValue( //�U�程讑֮�自己的PVOID数组单元�?br>DWORD dwTlsIndex,
PVOID pvTlsValue);

PVOID TlsGetValue(
DWORD dwTlsIndex); //��索PVOID数组�?/p>

BOOL TLSFree(
DWORD dwTlsIndex); //释放PVOID数组单元

静态TLS:__declspec(thread) DWORD gt_dwStartTime=0;//只能修饰全局或者静态变量�?/p>

DLL挂接�Q�进�E�注入）�Q�让自己的DLL插入到其他进�E�的地址�I�间�?/p>

1 使用注册表插入DLL
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows\AppInit_DLLs
��你的DLL路径攑օ��q�个关键字下面。当User32.dll被映��到�q�程中的时候，它会加在�q�个关键字下的每个库�?br>注意�Q�（1�Q�对win98无效
      �Q?�Q�由于加载事间比较早�Q�你的DLL可能无法调用kernel32以外的dll.
       (3) 如果�q�程没有使用user32.dll�Q�这个方法无效�?br>       (4) 需要重新启动�?br>      �Q?�Q�user32不会��查每个库是否加蝲成功�?br>2 使用windows钩子
HOOK hHook=SetWindowsHookEx(WH_GETMESSAGE,GetMsgProc,hinstDll,0);
BOOL UnhookWindowsHookEx(HHOOK hhook);
具体�q�程如下�Q?br>      �Q?�Q�进�E�B的一个线�E�准备发送消息给一个窗口�?br>      �Q?�Q�系�l�察看线�E�上是否已经安装了WH_GETMESSAGE钩子�?br>      �Q?�Q�系�l�察看GetMsgProc的DLL是否已经映射��C��q�程B的地址�I�间�Q�如果没有，�pȝ��把DLL映射到B的地址�I�间�Q��ƈ自动增加引用计数�?br>      �Q?�Q�调用GetMsgProc函数�Q�返回时�Q�系�l�会自动为DLL的引用计数减一�?/p>

3 使用�q�程�U�程来插入DLL
(1)使用VirtualAllocEx,分配�q�程�q�程的地址�I�间的内存�?br> (2)使用WriteProcessMemory,��Dll的�\径名拯��到第一个步骤中已经分配的内存中�?br> (3)使用GetProcAddress,获得LoadLibrary的实际地址�?br> (4)使用CreateRemoteThread,在远�E�进�E�中创徏一个线�E��?br> 退出：
(5)使用VirtualFreeEx�Q�释攑ֆ��?br> (6)使用GetProcAddress,获得FreeLiabary的地址�?br> (7)使用CreateRemoteThread,在远�E�进�E�中创徏一个线�E�，调用FreeLiabary函数�?br>4 使用�Ҏ��伊DLL插入
替换dll.
5 ��DLL作�ؓ调试�E�序插入
6 win98内存映射文�g�Q�creatprocess

�l�构化异常处理：
�l�束处理�E�序�Q�__try{} __finally{}
除非__try执行中进�E�或者线�E�结束，否则��M��执行__finally�Q��ƈ且__finally中的return会替代__try中的return;好的习惯是将return ,continue,break,goto语句拿到�l�构化异常处理语句外面，可以节省开销。将__try中的return 换成__leave�Q�可以节省开销。在__finally�ȝ��定时正常�q�入�q�是展开�q�入�Q?br>BOOL AbnormalTermination();//正常�q�入�q�回FALSE,局部展开或者全局展开�q�回TRUE;

异常处理�E�序�Q�__try{}__exception(异常�q��o表达�?{}

EXCEPTION_EXECUTE_HANDLE
表示处理异常�Q�处理后转到exception块后面的代码�l�箋执行�?br>EXCEPTION_CONTINUE_EXECUTION
EXCEPTION_CONTINUE_SEARCH

可以对异常过滤表辑ּ��q�行��编码，也可以用一个调用一个函数来军_��q��o表达式，函数的返回值是LONG.例如�Q�可以进行一定处理，然后�q�回EXCEPTION_CONTINUE_EXECUTION�Q�再�ơ执行出错语句。但可能再次出错�Q�因此这�U�方法必��d��心，防止生成��d�@环�?/p>

DWORD GetExceptionCode() 可以获得异常�U�类。它只能在__except后的括号或者异常处理程序中调用�?/p>

发生异常后，操作�pȝ��会像引�v异常的线�E�的栈里压入三个�l�构:EXCEPTION_RECORD CONTEXT EXCEPTION_POINTERS,其中�W�三个结构包含两个成员指针，分别指向前两个结构，使用函数可以获得�W�三个结构的指针�Q?br>PEXCEPTION_POINTERS GetExceptionInformation();//仅可以在异常�q��o器中调用,既__exception后面的小括号�?/p>

逗号表达式：从左到右�Ҏ��有的表达式求��|��q�返回最有面的表辑ּ�的倹{�?/p>

引发软�g异常�Q?br>VOID RaiseException(
DWORD dwExceptionCode,
DWORD dwExceptionFlags,
DWORD nNumberOfArguments,
CONST ULONG_PTR *pArguments);

�~�省调试器所在注册表�Q?br>HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug Debugger
win98是存攑֜�win.ini�?/p>

调试器挂接到被调试进�E?br>BOOL DebugActiveProcess(DWORD dwProcessID);

while(*str++!='\0');
应该注意的是在不满��条�g后，str仍然会自�?�?/p>

位操作符>>�?lt;<不会做��@环位�U�，即不会把�U�d��的位攑ֈ�另一头�?/p>

多态性和动态联�~�的实现�q�程分析

　　一、基��Q?/p>

　　1、多态性：使用基础�cȝ��指针动态调用其�z��c�M��函数的特性�?/p>

　　2、动态联�~�：在运行阶�D�，才将函数的调用与对应的函��C��q�行�q�接的方式，又叫�q�行时联�~�或晚捆�l��?/p>

　　二、过�E�描�q�ͼ�

　　1、编译器发现一个类中有虚函敎ͼ��~�译器会立即为此�cȝ��成虚拟函数表 vtable�Q�后面有对vtable的分析）。虚拟函数表的各表项为指向对应虚拟函数的指针�?/p>

　　2、编译器在此�c�M��隐含插入一个指针vptr�Q�对vc�~�译器来��_��它插在类的第一个位�|�上�Q��?/p>

　　有一个办法可以让你感知这个隐含指针的存在�Q�虽然你不能在类中直接看到它�Q�但你可以比较一下含有虚拟函数时的类的尺寸和没有虚拟函数时的�cȝ��寸�Q�你能够发现�Q�这个指针确实存在�?

　　3、在调用此类的构造函数时�Q�在�cȝ��构造函��C��Q�编译器会隐含执行vptr与vtable的关联代码，��vptr指向对应的vtable。这��将�c�M��此类的vtable联系了�v来�?/p>

　　4、在调用�cȝ��构造函数时�Q�指向基��cȝ��指针此时已经变成指向具体的类的this指针�Q�这样依靠此this指针卛_��得到正确的vtable�Q�从而实��C��多态性。在此时才能真正与函��C��q�行�q�接�Q�这��是动态联�~��?/p>

定义�U�虚函数�Ҏ��Q�virtual returntype function()= 0;

所有的�c�d��都可以用new动态创建，包括�c�，�l�构�Q�内�|�数据类型�?/p>

exit()函数包含�?cstdlib"�?/p>

泛型�~�程�Q��用STL�?br>��d��有近75个泛型算�?/p>

所有容器的共通操作：
== != = empty() size() clear(),begin(),end(),以及insert和erase,不过后者随容器的的不同而不�?/p>

序列式容器：
vector(数组):插入和删除的效率较低�Q�但存取效率高�?br>list�Q�双向链表）:与前者相反，插入和删除的效率较高�Q�但存取效率低。每个元素包含三个字�D�：value back front.
deque(队列):在前端和末尾操作效率高�?/p>

生成序列式容器的五种�Ҏ��Q?br>1 产生�I�的容器�Q?br>list slist;
vector vtor;
2 产生特定大小的容器，容器中的每个元素都以光��认��gؓ初��|��发现VC中的int double�{�没有默认��|��?br>list ilist(1024);
vector svec(24);
3 产生特定大小的容器，�q��ؓ每个元素指定初��|��
listvector svec(24,"default");
4 通过一对�P代器产生容器�Q�这对�P代器用来表示数组作�ؓ初值的区间�Q?br>int ia[10]={1,2,3,4,5,6,7,8,9,0};
vector iv(ia+2,ia+8);
5 复制某个现有的容器的��|��
vector ivec1;
//填充ivec1;
vector ivec2(ivec1);

�?个方法用于操作开始和末尾的元素：push_front() pop_front() push_back() pop_back(),�׃��pop操作仅删除元素而不�q�回元素�Q�因此还需要front() back()�Ҏ��取开始和末尾的元素，另外�Q�vector不包括push_front() pop_front�Ҏ��Q�很昄��Q�无法实现�?/p>

intert的四�U�变形：
iterator insert(iterator position,elemType value):��value插到position前。返回值指向被插入的元素�?br>void insert(iterator position,int count,elemType value):在position前插入count个元素，每个元素都是value.
void insert(iterator1 position,iterator2 first,iterator2 last):��first,last之间的元素插到position�?
iterator insert( iterator position):在position前插入元素，初��gؓ所属类型的默认倹{�?/p>

erase的两�U�变形：
1 iterator erase(iterator posit):删除posit指向的元素�?br>list::iterator it=find(slist.begin(),slist,end(),str);
slist.erase(it);
2 iterator erase(iterator first,iterator last):删除first,last间的元素�?/p>

list不支持iterator的偏�U�运��?/p>

对于常值容器，使用常�P代器�Q?br>const vector cs_vec;
vector

iterator可以当作指针用，可以�?取内容，也可以用->调用对象的成员�?/p>

使用泛型��法
�Q�i nclude

find():�U�性搜索无序集�?br>binary_search():二分搜烦有序集合�?br>count()�Q�返回元素个数�?br>search():搜烦序列�Q�如果存在返回的iterator指向序列首部�Q�否则指向容器末��?br>max_element(begin,end):�q�回区间内的最大倹{�?br>copy(begin,end,begin):元素复制�?br>sort(begin,end):排序�?/p>

function objects:�Q�i nclude
��术�q�算�Q?br>plus minus negate multiplies divides modules
关系�q�算�Q?br>less less equal greater equal_to not_equal_to
逻辑�q�算�Q?br>logical_and logical_or logical_not

adapter:适配器�?br>bind1st:��数值绑定到function object的第一个参数�?br>bind2nd:��数值绑定到function object的第二个参数�?/p>

使用map:
�Q�i nclude
�Q�i nclude
map words;

words["vermeer"]=1;

map::iterator it=words.begin();
for(;it!=words.end();++it)
cout<<"key:"<first<<"value:"<second<

查找map元素的方�?
words.find("vermeer");//�q�回iterator,指向扑ֈ�的元素，找不到返回end();
�q�可以：
if(words.count(search_word))
count=words[search_word];

使用set:
�Q�i nclude
�Q�i nclude
set word_exclusion;
//判断是否存在某个元素
if(word_exclusion.count(tword))
//默认情况下，所有元素按less-than�q�算排列

//加入元素
iset.insert(ival);
iset.insert(vec.begin(),vec.end());

与set相关的算�?br>set_intersection() set_union() set_difference() set_symmetric_difference()

使用insertion adapters:
�Q�i nclude
back_inserter()
inserter()
front_inserter()

使用STL通常会有很多警告�Q��ؓ了避免在调试模式�Q�debug mode�Q�出现恼人的警告�Q��用下面的�~�译器命令：

#pragma warning(disable: 4786)

strncpy(dest,source,count) if(count�?strlen(source)),那么null�l�尾不会被加在dest的尾部，如果count>strlen(source),那么不��的部分会用null填充�?/p>

windows内存是由高地址向底地址分配的，但变量的存储是从底地址到高地址的，如INT�c�d��的四个字节，数组的每个元素�?br>
内存复制的时候不能用字符串拷贝函敎ͼ�因�ؓ即��使用strncpy指定了复制的长度�Q�拷贝函��C��会遇�?\0'自动�l�止�Q�要使用MEMSET�?/p>

�׃��寚w��的关�p�，下面两个�l�构使用sizeof�Q�前者是12�Q�后者是16�?br>struct DNSAnswer
{
unsigned short name;
unsigned short type;
unsigned short cla;
unsigned short length;
unsigned int   ttl;
};
struct DNSAnswer
{
unsigned short name;
unsigned short type;
unsigned short cla;
unsigned int   ttl;
        unsigned short length;
};

子类可以使用父类的保护成员，而友元比子类的权限还大，可以使用�cȝ��U�有和保护成员�?/p>

在内存分配失败的情况下，�pȝ��只有在出错处理函��Cؓ�I�的情况下，才会抛出异常�Q�std::bad_alloc(),否则会反复调用处理函数�ƈ再次��试分配内存�?/p>

如果重蝲了NEW�Q�那么在�l�承的时候要��心�Q�如果子�c�L��有覆盖NEW�Q�那么它会去使用父类的NEW �Q�因此应该在new�Q�delete中做��?br>if (size != sizeof(base)) // 如果数量“错误”�Q�让标准operator new�Q�base为类�?br> return ::operator new(size); // ��d��理这个请�?/p>

if (size != sizeof(base)) { // 如果size"错误"�Q?br> ::operator delete(rawmemory); // 让标准operator来处理请�?br> return;
}

c++标准规定�Q�要支持0内存��h��Q�分配一个字节）�Q��ƈ且可以删除NULL指针�Q�直接返回）�?/p>

在创建线�E�的时候，传递的变量一定要是全局或者静态的变量�Q�因��Z��递的是变量的地址�Q�如果是局部变量地址很快��׃��失效�?/p>

�ȝ��E�退出后�Q�其子线�E�自动结束�?/p>

��指针�Q�它可以避免内存泄露�Q�因为智能指针是在栈上创建的�Q�还可以避免堆上内存的重复释��N��误，因�ؓ它保证只有一个指针拥有这块内存的所有权�?/p>

Xiao.Zhu 2007-08-13 09:22 发表评论

linux下基于jrtplib库的实时传送实�?

Xiao.Zhu — Wed, 08 Aug 2007 08:39:00 GMT

linux 下基于jrtplib库的实时传送实�?br>一、RTP 是进行实时流媒体传输的标准协议和关键技�?br> 实时传输协议�Q�Real-time Transport Protocol�Q�PRT�Q�是�?nbsp;Internet 上处理多媒体数据��的一�U�网�l�协议，利用它能够在一对一�Q�unicast�Q�单播）或者一对多�Q�multicast�Q�多播）的网�l�环境中实现传流媒体数据的实时传输。RTP 通常使用 UDP 来进行多媒体数据的传输，但如果需要的话可以��?nbsp;TCP 或�?nbsp;ATM �{�其它协议�?br> 协议分析 �Q�每一个RTP数据报都由头部（Header�Q�和负蝲�Q�Payload�Q�两个部分组成，其中头部�?nbsp;12 个字节的含义是固定的�Q�而负载则可以是音频或者视频数据�?br>
      RTP 是目前解��x��媒体实时传输问题的最好办法，要在 Linux �q�_��上进行实时传送编�E�，可以考虑使用一些开放源代码�?nbsp;RTP 库，�?nbsp;LIBRTP、JRTPLIB �{�。JRTPLIB 是一个面向对象的 RTP 库，它完全遵�?nbsp;RFC 1889 设计�Q�在很多场合下是一个非�怸�错的选择。JRTPLIB 是一个用 C++ 语言实现�?nbsp;RTP 库，�q�个库��用socket 机制实现�|�络通讯因此可以�q�行�?nbsp;Windows、Linux、FreeBSD、Solaris、Unix和VxWorks �{�多�U�操作系�l�上�?br>二、JRTPLIB 库的使用�Ҏ��及程序实�?br> (1)JRTPLIB  函数的��?br> a、在使用 JRTPLIB �q�行实时��媒体数据传输之前，首先应该生成 RTPSession �cȝ��一个实例来表示此次 RTP 会话�Q�然后调�?nbsp;Create() �Ҏ��来对其进行初始化操作。RTPSession �cȝ�� Create() �Ҏ��只有一个参敎ͼ�用来指明此次 RTP 会话所采用的端口号�?br> RTPSession sess;  sess.Create(5000);

b、设�|�恰当的时戳单元�Q�是 RTP 会话初始化过�E�所要进行的另外一��w��要工作，�q�是通过调用 RTPSession �cȝ�� SetTimestampUnit() �Ҏ��来实现的�Q�该�Ҏ��同样也只有一个参敎ͼ�表示的是以秒为单元的时戳单元�?br> sess.SetTimestampUnit(1.0/8000.0);

c、当 RTP 会话成功建立��h��之后�Q�接下去��可以开始进行流媒体数据的实时传输了。首先需要设�|�好数据发送的目标地址�Q�RTP 协议允许同一会话存在多个目标地址�Q�这可以通过调用 RTPSession �cȝ�� AddDestination()、DeleteDestination() �?nbsp;ClearDestinations() �Ҏ��来完成。例如，下面的语句表�C�的是让 RTP 会话��数据发送到本地��L��?nbsp;6000 端口�Q?nbsp;

unsigned long addr = ntohl(inet_addr("127.0.0.1"));
sess.AddDestination(addr, 6000);

d、目标地址全部指定之后�Q�接着��可以调�?nbsp;RTPSession �cȝ�� SendPacket() �Ҏ��Q�向所有的目标地址发送流媒体数据。SendPacket() �?nbsp;RTPSession �c�L��供的一个重载函�?br>对于同一�?nbsp;RTP 会话来讲�Q�负载类型、标识和时戳增量通常来讲都是相同的，JRTPLIB 允许��它们设�|��ؓ会话的默认参敎ͼ��q�是通过调用 RTPSession �cȝ�� SetDefaultPayloadType()、SetDefaultMark() �?nbsp;SetDefaultTimeStampIncrement() �Ҏ��来完成的。�ؓ RTP 会话讄��q�些默认参数的好处是可以��化数据的发送，例如�Q�如果�ؓ RTP 会话讄��了默认参敎ͼ�

sess.SetDefaultPayloadType(0);
  sess.SetDefaultMark(false);
sess.SetDefaultTimeStampIncrement(10);

之后在进行数据发送时只需指明要发送的数据及其长度��可以了�Q?nbsp;

sess.SendPacket(buffer, 5);

e、对于流媒体数据的接收端�Q�首先需要调�?nbsp;RTPSession �cȝ�� PollData() �Ҏ��来接收发送过来的 RTP 或�?nbsp;RTCP 数据报。由于同一�?nbsp;RTP 会话中允许有多个参与者（源）�Q�你既可以通过调用 RTPSession �cȝ�� GotoFirstSource() �?nbsp;GotoNextSource() �Ҏ��来遍历所有的源，也可以通过调用 RTPSession �cȝ�� GotoFirstSourceWithData() �?nbsp;GotoNextSourceWithData() �Ҏ��来遍历那些携带有数据的源。在�?nbsp;RTP 会话中检��出有效的数据源之后�Q�接下去��可以调�?nbsp;RTPSession �cȝ�� GetNextPacket() �Ҏ��从中抽取 RTP 数据报，当接收到�?nbsp;RTP 数据报处理完之后�Q�一定要记得及时释放�?br>
JRTPLIB �?nbsp;RTP 数据报定义了三种接收模式�Q�其中每�U�接收模式都具体规定了哪些到辄�� RTP 数据报将会被接受�Q�而哪些到辄�� RTP 数据报将会被拒绝。通过调用 RTPSession �cȝ�� SetReceiveMode() �Ҏ��可以讄��下列�q�些接收模式�Q?nbsp;
? RECEIVEMODE_ALL　　�~�省的接收模式，所有到辄�� RTP 数据报都��被接受�Q?nbsp;
? RECEIVEMODE_IGNORESOME　　除了某些特定的发送者之外，所有到辄�� RTP 数据报都��被接受�Q�而被拒绝的发送者列表可以通过调用 AddToIgnoreList()、DeleteFromIgnoreList() �?nbsp;ClearIgnoreList() �Ҏ��来进行设�|�；
? RECEIVEMODE_ACCEPTSOME　　除了某些特定的发送者之外，所有到辄�� RTP 数据报都��被拒绝�Q�而被接受的发送者列表可以通过调用 AddToAcceptList ()、DeleteFromAcceptList �?nbsp;ClearAcceptList () �Ҏ��来进行设�|��?nbsp;下面是采用第三种接收模式的程序示例�?br> if (sess.GotoFirstSourceWithData()) {
  do {
   sess.AddToAcceptList(remoteIP, allports,portbase);
          sess.SetReceiveMode(RECEIVEMODE_ACCEPTSOME);

    RTPPacket *pack;
    pack = sess.GetNextPacket();            // 处理接收到的数据
    delete pack;   }
  while (sess.GotoNextSourceWithData());
  }

  �Q?�Q�程序流�E�图
发送：获得接收端的 IP 地址和端口号        创徏 RTP 会话        指定 RTP 数据接收�?nbsp;讄�� RTP 会话默认参数   发送流媒体数据
接收�Q�获得用��h��定的端口�?nbsp; 创徏RTP会话  讄��接收模式  接受RTP数据  ��索RTP数据�?nbsp; 获取RTP数据�?nbsp; 删除RTP数据�?br>

三、环境搭建及�~�译�Ҏ��
�Q?�Q�Toolchain的安�?br> 首先扑ֈ�xscale-arm-toolchain.tgz文�g�Q�假设该文�g包放�?tmp/�?br> #cd /
#tar -zxvf /tmp/xscale-arm-toolchain.tgz
再设�|�环境变�?br> #export PATH=/usr/local/arm-linux/bin:$PATH
最后检查一下交叉编译工��h��否安装成�?br> #arm-linux-g++ --version
看是否显�C�arm-linux-g++的版本，如有则安装成功�?br>�Q?�Q�JRTPLIB 库的交叉�~�译及安�?br> 首先�?nbsp;JRTPLIB 的网站（http://lumumba.luc.ac.be/jori/jrtplib/jrtplib.htmll�Q?nbsp;下蝲最新的源码包，此处使用的是jrtplib-2.8.tar�Q�假设下载后的源码包攑֜�/tmp下，�?nbsp;行下面的命��o对其解压�~�：
#cd /tmp
#tar -zxvf jrtplib-2.8.tar
然后要对jrtplib�q�行配置和编�?br> #cd jrtplib-2.8
#./configure CC=arm-linux-g++ cross-compile=yes
修改Makefile文�g
��链接命令ld 和ar改�ؓarm-linux-ld�?nbsp;arm-linux-ar
#make
最后再执行如下命��o��可以完�?nbsp;JRTPLIB 的安装：
#make install
(3)�E�序�~�译
a、配�|�编译环�?br> 可以用export来配�|�，也可以用�~�写Makefile的方法。这里采用Makefile�?br> �~�写Makefile&:
INCL = -I/usr/local/include
CFLAGS = -pipe -O2 -fno-strength-reduce
LFLAGS = /usr/local/lib/libjrtp.a -L/usr/X11R6/lib
LIBS = -LX11 -LXext /usr/local/lib/libjrtp.a
CC = arm-linux-g++

main:main.o
$(CC) $(LFLAGS) $(INCL) -o main main.o $(LIBS)
main.o:main.cpp

clean:
rm -f main
rm -f *.o

.SUFFIXES:.cpp
.cpp.o:
$(CC) -c $(CFLAGS) $(INCL) -o $@ $<         /*  $@表示目标的完整名�?nbsp;     */
          /* $<表示�W�一个依赖文件的名字 */
b、编�?br> 假设发送和接收�E�序分别攑֜�/tmp/send�?tmp/receive目录�?br> #cd /tmp/send
#make
#cd /tmp/receive
#make

四、易出错误及注意问题
1、找不到一些标准的最基本的一些头文�g�?br>  主要是因为Toolchain路径没安装对�Q�要严格按照步骤安装�?br> 2、找不到使用的jrtplib库中的一些头文�g�?br>  �?nbsp;jrtplib的安装目录下�Q�include路径下不能再有别的目录�?br> 3、recieve函数接收数据包不能正��提出所要数据�?br>  �׃��每一个RTP数据报都由头部（Header�Q�和负蝲�Q�Payload�Q�两个部分组成，若��用getrawdata()是返回整个数据包的数据，包含传输媒体的类型、格式、序列号、时间戳以及是否有附加数据等信息。getpayload()函数是返回所发送的数据。两者一定要分清�?br> 4、设�|�RECEIVEMODE_ACCEPTSOME　　接收模式后，�q�行�E�序接收端不能接包�?br>  IP地址格式��Z��问题。iner_addr()与ntohl()函数要用对，否则参数传不�q�去�Q�接受列表中无��|��当然接收不了数据包�?br> 5、编译通过�Q�但��试时接收端不能接收到数据�?br>  可能是接收机防火墙未关闭。运行：
  #iptables -F
  也可能是IP地址没有讄��好。运行：
  #ifocnfig eth0  *.*.*.*  netmask *.*.*.*
6、��用jrtolib库时�Q�在�E�序中include 后最好加上库所在的路径�?br>五、程�?br>
send:

#include
#include
#include "rtpsession.h"

// 错误处理函数
void checkerror(int err)
{
  if (err < 0) {
    char* errstr = RTPGetErrorString(err);
    printf("Error:%s\\n", errstr);
    exit(-1);
  }
}

int main(int argc, char** argv)
{
  RTPSession sess;
  unsigned long destip;
  int destport;
  int portbase = 6000;
  int status, index;
  char buffer[128];

  if (argc != 3) {
    printf("Usage: ./sender destip destport\\n");
    return -1;
  }

  // 获得接收端的IP地址和端口号
  destip = inet_addr(argv[1]);
  if (destip == INADDR_NONE) {
    printf("Bad IP address specified.\\n");
    return -1;
  }
  destip = ntohl(destip);
  destport = atoi(argv[2]);

  // 创徏RTP会话
  status = sess.Create(portbase);
  checkerror(status);

  // 指定RTP数据接收�?br>  status = sess.AddDestination(destip, destport);
  checkerror(status);

  // 讄��RTP会话默认参数
  sess.SetDefaultPayloadType(0);
  sess.SetDefaultMark(false);
  sess.SetDefaultTimeStampIncrement(10);

  // 发送流媒体数据
  index = 1;
  do {
    sprintf(buffer, "%d: RTP packet", index ++);
    sess.SendPacket(buffer, strlen(buffer));
    printf("Send packet !\\n");
  } while(1);

  return 0;
}

receive:

#include
#include "rtpsession.h"
#include "rtppacket.h"

// 错误处理函数
void checkerror(int err)
{
  if (err < 0) {
    char* errstr = RTPGetErrorString(err);
    printf("Error:%s\\n", errstr);
    exit(-1);
  }
}

int main(int argc, char** argv)
{
  RTPSession sess;
  int localport,portbase;
  int status;
  unsigned long remoteIP;
  if (argc != 4) {
    printf("Usage: ./sender localport\\n");
    return -1;
  }

   // 获得用户指定的端口号

  remoteIP = inet_addr(argv[1]);
  localport = atoi(argv[2]);
  portbase = atoi(argv[3]);
  // 创徏RTP会话
  status = sess.Create(localport);
  checkerror(status);

  //RTPHeader *rtphdr;
  unsigned long timestamp1;
  unsigned char * RawData;
  unsigned char temp[30];
  int lengh ,i;
  bool allports = 1;

  sess.AddToAcceptList(remoteIP, allports,portbase);

     do {
//讄��接收模式
        sess.SetReceiveMode(RECEIVEMODE_ACCEPTSOME);
   sess.AddToAcceptList(remoteIP, allports,portbase);

    // 接受RTP数据
    status = sess.PollData();


// ��索RTP数据�?br>    if (sess.GotoFirstSourceWithData()) {
      do {

        RTPPacket* packet;
        // 获取RTP数据�?br>        while ((packet = sess.GetNextPacket()) != NULL) {
          printf("Got packet !\n");

   timestamp1 = packet->GetTimeStamp();
   lengh=packet->GetPayloadLength();
   RawData=packet->GetPayload();

   for(i=0;i      temp[i]=RawData[i];
  printf("%c",temp[i]);
   }
   temp[i]='\0';
   printf("  timestamp: %d lengh=%d data:%s\n",timestamp1,lengh,&temp);
          // 删除RTP数据�?br>
          delete packet;
        }
      } while (sess.GotoNextSourceWithData());
    }
  } while(1);

  return 0;
}

Xiao.Zhu 2007-08-08 16:39 发表评论

RTP

Xiao.Zhu — Wed, 08 Aug 2007 08:38:00 GMT

��媒体指的是在网�l�中使用��技术传输的�q�箋时基媒体�Q�其特点是在播放前不需要下载整个文�Ӟ��而是采用边下载边播放的方式，它是视频会议�?span>IP电话�{�应用场合的技术基��?span>RTP是进行实时流媒体传输的标准协议和关键技术，本文介绍如何�?span>Linux下利�?span>JRTPLIB�q�行实时��媒体编�E��?nbsp;

一、流媒体��?/span>
随着Internet的日益普及，在网�l�上传输的数据已�l�不再局限于文字和图形，而是逐渐向声韛_��视频�{�多媒体格式�q�渡。目前在�|�络上传输音�?span>/视频�Q?span>Audio/Video�Q�简�U?span>A/V�Q�等多媒体文件时�Q�基本上只有下蝲和流式传输两�U�选择。通常说来�Q?span>A/V文�g占据的存储空间都比较大，在带宽受限的�|�络环境中下载可能要耗费数分钟甚��x��时�Q�所以这�U�处理方法的延迟很大。如果换用流式传输的话，声音、媄像、动�ȝ��多媒体文件将�׃��门的��媒体服务器负责向用戯��l�、实时地发送，�q�样用户可以不必�{�到整个文�g全部下蝲完毕�Q�而只需要经�q�几�U�钟的启动�g时就可以了，当这些多媒体数据在客��h��上播放时�Q�文件的剩余部分��l�从��媒体服务器下蝲�?/span>

��（Streaming�Q�是�q�年�?span>Internet上出现的新概念，其定义非常广泛，主要是指通过�|�络传输多媒体数据的技术�ȝ��。流媒体包含�q�义和狭义两�U�内涵：�q�义上的��媒体指的是佉K��频和视频形成�E�_��和连�l�的传输��和回放��的一�p�d��技术、方法和协议的�ȝ��Q�即��媒体技术；狭义上的��媒体是相对于传�l�的下蝲-回放方式而言的，指的是一�U�从Internet上获取音频和视频�{�多媒体数据的新�Ҏ��Q�它能够支持多媒体数据流的实时传输和实时播放。通过�q�用��媒体技术，服务器能够向客户机发送稳定和�q�箋的多媒体数据��，客户机在接收数据的同时以一个稳定的速率回放�Q�而不用等数据全部下蝲完之后再�q�行回放�?/span>

�׃��受网�l�带宽、计��机处理能力和协议规范等斚w��的限�Ӟ��要想�?span>Internet上下载大量的音频和视频数据，无论从下载时间和存储�I�间上来讲都是不太现实的�Q�而流媒体技术的出现则很好地解决了这一��N��。目前实现流媒体传输主要有两�U�方法：��序��（progressive streaming�Q�传输和实时��（realtime streaming�Q�传输，它们分别适合于不同的应用场合�?/span>

��序��传�?/span>

��序��传输采用顺序下载的方式�q�行传输�Q�在下蝲的同时用户可以在�U�回攑֤�媒体数据�Q�但�l�定时刻只能观看已经下蝲的部分，不能跛_��未下蝲的部分，也不能在传输期间�Ҏ��|�络状况对下载速度�q�行调整。由于标准的HTTP服务器就可以发送这�U��Ş式的��媒体，而不需要其他特�D�协议的支持�Q�因此也常常被称�?span>HTTP ��式传输。顺序流式传输比较适合于高质量的多媒体片段�Q�如片头、片��或者广告等�?/span>

实时��传�?/span>

实时��式传输保证媒体信号带宽能够与当前网�l�状�늛�匚w��Q�从而��得流媒体数据��L��被实时地传送，因此特别适合于现��Z��件。实时流传输支持随机讉K��Q�即用户可以通过快进或者后退操作来观看前面或者后面的内容。从理论上讲�Q�实时流媒体一�l�播攑ְ�不会停顿�Q�但事实上仍有可能发生周期性的暂停现象�Q�尤其是在网�l�状冉|��化时更是如此。与��序��传输不同的是，实时��传输需要用到特定的��媒体服务器�Q�而且�q�需要特定网�l�协议的支持�?/span>

二、流媒体协议
实时传输协议�Q?span>Real-time Transport Protocol�Q?span>PRT�Q�是�?span>Internet上处理多媒体数据��的一�U�网�l�协议，利用它能够在一对一�Q?span>unicast�Q�单播）或者一对多�Q?span>multicast�Q�多播）的网�l�环境中实现传流媒体数据的实时传输�?span>RTP通常使用UDP来进行多媒体数据的传输，但如果需要的话可以��?span>TCP或�?span> ATM�{�其它协议，整个RTP协议�׃��个密切相关的部分�l�成�Q?span>RTP数据协议�?span>RTP控制协议。实时流协议�Q?span>Real Time Streaming Protocol�Q?span>RTSP�Q�最早由Real Networks�?span>Netscape公司共同提出�Q�它位于RTP�?span>RTCP之上�Q�其目的是希望通过IP�|�络有效��C��输多媒体数据�?/span>

2.1 RTP数据协议

RTP数据协议负责�Ҏ��媒体数据�q�行��包�q�实现媒体流的实时传输，每一�?span>RTP数据报都由头部（Header�Q�和负蝲�Q?span>Payload�Q�两个部分组成，其中头部�?span>12个字节的含义是固定的�Q�而负载则可以是音频或者视频数据�?span>RTP数据报的头部格式如图1所�C�：

�?span>1 RTP头部格式

其中比较重要的几个域及其意义如下�Q?nbsp;

CSRC记数�Q?span>CC�Q?/span>　　表示CSRC标识的数目�?span>CSRC标识紧跟�?span>RTP固定头部之后�Q�用来表�C?span>RTP数据报的来源�Q?span>RTP协议允许在同一个会话中存在多个数据源，它们可以通过RTP混合器合�q��ؓ一个数据源。例如，可以产生一�?span>CSRC列表来表�C�Z��个电话会议，该会议通过一�?span> RTP混合器将所有讲话者的语音数据�l�合��Z��?span>RTP数据源�?nbsp;
负蝲�c�d��Q?span>PT�Q?/span>　　标明RTP负蝲的格式，包括所采用的编码算法、采样频率、承载通道�{�。例如，�c�d��2表明�?span>RTP数据包中承蝲的是�?span>ITU G.721��法�~�码的语��x��据，采样频率�?span>8000Hz�Q��ƈ且采用单声道�?nbsp;
序列�?/span>　　用来为接收方提供探测数据丢失的方法，但如何处理丢��q��数据则是应用�E�序自己的事情，RTP协议本��n�q�不负责数据的重传�?nbsp;
旉��?/span>　　记录了负载中�W�一个字节的采样旉��Q�接收方能够旉��戌��够确定数据的到达是否受到了�g�q�抖动的影响�Q�但具体如何来补偿�g�q�抖动则是应用程序自��q��事情�?nbsp;

�?span>RTP 数据报的格式不难看出�Q�它包含了传输媒体的�c�d��、格式、序列号、时间戳以及是否有附加数据等信息�Q�这些都为实时的��媒体传输提供了相应的基��?span>RTP协议的目的是提供实时数据�Q�如交互式的音频和视频）的端到端传输服务�Q�因此在RTP中没有连接的概念�Q�它可以建立在底层的面向�q�接或面向非�q�接的传输协议之上；RTP也不依赖于特别的�|�络地址格式�Q�而仅仅只需要底层传输协议支持组帧（Framing�Q�和分段�Q?span>Segmentation�Q�就��_��了；另外RTP 本��n�q�不提供��M��可靠性机�Ӟ��q�些都要�׃��输协议或者应用程序自己来保证。在典型的应用场合下�Q?span>RTP 一般是在传输协议之上作为应用程序的一部分加以实现的，如图2所�C�：

�?span>2 RTP与各�U�网�l�协议的关系

2.2 RTCP控制协议

RTCP 控制协议需要与RTP数据协议一起配合��用，当应用程序启动一�?span>RTP会话时将同时占用两个端口�Q�分别供RTP �?span>RTCP使用�?span>RTP本��n�q�不能�ؓ按序传输数据包提供可靠的保证�Q�也不提供流量控制和拥塞控制�Q�这些都�?span>RTCP来负责完成。通常RTCP会采用与 RTP相同的分发机�Ӟ��向会话中的所有成员周期性地发送控制信息，应用�E�序通过接收�q�些数据�Q�从中获取会话参与者的相关资料�Q�以及网�l�状��c��分�l�丢失概率等反馈信息�Q�从而能够对服务质量�q�行控制或者对�|�络状况�q�行诊断�?/span>

RTCP协议的功能是通过不同�?span>RTCP数据报来实现的，主要有如下几�U�类型：

SR　　发送端报告�Q�所谓发送端是指发出RTP数据报的应用�E�序或者终端，发送端同时也可以是接收端�?nbsp;
RR　　接收端报告，所谓接收端是指仅接收但不发�?span>RTP数据报的应用�E�序或者终端�?nbsp;
SDES　　源描�q�ͼ�主要功能是作��Z��话成员有��x��识信息的载体�Q�如用户名、邮件地址、电话号码等�Q�此外还��h��向会话成员传达会话控制信息的功能�?nbsp;
BYE　　通知��d��Q�主要功能是指示某一个或者几个源不再有效�Q�即通知会话中的其他成员自己��退��Z��话�?nbsp;
APP　　由应用程序自己定义，解决�?span>RTCP的扩展性问题，�q�且为协议的实现者提供了很大的灵�z�L��?nbsp;

RTCP数据报携带有服务质量监控的必要信息，能够�Ҏ��务质量进行动态的调整�Q��ƈ能够对网�l�拥塞进行有效的控制。由�?span>RTCP数据报采用的是多播方式，因此会话中的所有成员都可以通过RTCP数据报返回的控制信息�Q�来了解其他参与者的当前情况�?/span>

在一个典型的应用场合下，发送媒体流的应用程序将周期性地产生发送端报告SR�Q�该RTCP数据报含有不同媒体流间的同步信息�Q�以及已�l�发送的数据报和字节的计敎ͼ�接收端根据这些信息可以估计出实际的数据传输速率。另一斚w��Q�接收端会向所有已知的发送端发送接收端报告RR�Q�该RTCP数据报含有已接收数据报的最大序列号、丢��q��数据报数目、�g时抖动和旉��戳等重要信息�Q�发送端应用�Ҏ��q�些信息可以估计出往�q�时�Ӟ��q�且可以�Ҏ��数据报丢失概率和时�g抖动情况动态调整发送速率�Q�以改善�|�络拥塞状况�Q�或者根据网�l�状况��^滑地调整应用�E�序的服务质量�?/span>

2.3 RTSP实时��协�?/span>

作�ؓ一个应用层协议�Q?span>RTSP提供了一个可供扩展的框架�Q�它的意义在于��得实时流媒体数据的受控和�Ҏ��变得可能。�ȝ��说来�Q?span>RTSP是一个流媒体表示协议�Q�主要用来控制具有实时特性的数据发送，但它本��n�q�不传输数据�Q�而是必须依赖于下层传输协议所提供的某些服务�?span>RTSP 可以�Ҏ��媒体提供诸如播放、暂停、快�q�等操作�Q�它负责定义具体的控制消息、操作方法、状态码�{�，此外�q�描�q�C��?span>RTP间的交互操作�?/span>

RTSP 在制定时较多地参考了HTTP/1.1协议�Q�甚臌��多描�q�C��HTTP/1.1完全相同�?span>RTSP之所以特意��用与HTTP/1.1�c�M��的语法和操作�Q�在很大�E�度上是��Z��兼容现有�?span>Web基础�l�构�Q�正因如此，HTTP/1.1的扩展机制大都可以直接引入到RTSP 中�?/span>

�?span>RTSP 控制的媒体流集合可以用表�C�描�q�ͼ�Presentation Description�Q�来定义�Q�所谓表�C�是指流媒体服务器提供给客户机的一个或者多个媒体流的集合，而表�C�描�q�则包含了一个表�C�Z��各个媒体��的相关信息�Q�如数据�~�码/解码��法、网�l�地址、媒体流的内容等�?/span>

虽然RTSP服务器同样也使用标识�W�来区别每一��连接会话（Session�Q�，�?span>RTSP�q�接�q�没有被�l�定��C��输层�q�接�Q�如TCP�{�）�Q�也��是说在整个 RTSP�q�接期间�Q?span>RTSP用户可打开或者关闭多个对RTSP服务器的可靠传输�q�接以发�?span>RTSP ��h��。此外，RTSP�q�接也可以基于面向无�q�接的传输协议（�?span>UDP�{�）�?/span>

RTSP协议目前支持以下操作�Q?nbsp;

��索媒�?/span>　　允许用户通过HTTP或者其它方法向媒体服务器提交一个表�C�描�q�。如表示是组播的�Q�则表示描述��包含用于该媒体��的�l�播地址和端口号�Q�如果表�C�是单播的，��Z��安全在表�C�描�q�C��应该只提供目的地址�?nbsp;
邀请加�?/span>　　媒体服务器可以被邀请参加正在进行的会议�Q�或者在表示中回攑֪�体，或者在表示中录制全部媒体或其子集，非常适合于分布式教学�?nbsp;
��d��媒体　　通知用户新加入的可利用媒体流�Q�这对现��座来讲显得尤其有用。与HTTP/1.1�c�M��Q?span>RTSP��h��也可以交�׃��理、通道或者缓存来�q�行处理�?nbsp;

三、流媒体�~�程
RTP 是目前解��x��媒体实时传输问题的最好办法，如果需要在Linux�q�_��上进行实时流媒体�~�程�Q�可以考虑使用一些开放源代码�?span>RTP库，�?span>LIBRTP�?span> JRTPLIB�{��?span>JRTPLIB是一个面向对象的RTP库，它完全遵�?span>RFC 1889设计�Q�在很多场合下是一个非�怸�错的选择�Q�下面就�?span>JRTPLIB��Z��Q�讲�q�如何在Linux�q�_��上运�?span>RTP协议�q�行实时��媒体编�E��?/span>

3.1 环境搭徏

JRTPLIB 是一个用C++语言实现�?span>RTP库，目前已经可以�q�行�?span>Windows�?span>Linux�?span>FreeBSD�?span> Solaris�?span>Unix�?span>VxWorks�{�多�U�操作系�l�上。要�?span>Linux �pȝ��安装JRTPLIB�Q�首先从JRTPLIB的网站（http: //lumumba.luc.ac.be/jori/jrtplib/jrtplib.html�Q�下载最新的源码包，此处使用的是jrtplib- 2.7b.tar.bz2。假设下载后的源码包保存�?span>/usr/local/src目录下，执行下面的命令可以对其进行解压羃�Q?/span>

[root@linuxgam src]# bzip2 -dc jrtplib-2.7b.tar.bz2 | tar xvf -

Xiao.Zhu 2007-08-08 16:38 发表评论

Xiao.Zhu — Wed, 08 Aug 2007 08:23:00 GMT

摘要: 1 2//******************************************************************************************************* 3// loadEXE.cpp : Defines&nb... 阅读全文

Xiao.Zhu 2007-08-08 16:23 发表评论

Xiao.Zhu — Thu, 12 Jul 2007 04:46:00 GMT

摘要: 中国��Z��是文人相轻，而是��Z�h相轻�Q�只要想轻视别�h�Q��L��相轻的理由。比如北京�h轻视外地人，上�v��视外��C�h�Q�城里�h轻视农村人，南方��视北方�h�Q�有�׃�h轻视�I��h�Q�开车的轻视走�\的，走�\的轻视扫路的�Q�吃饭的轻视做饭的……就是不会相互尊重�?nbsp; 阅读全文

Xiao.Zhu 2007-07-12 12:46 发表评论

深圳

Xiao.Zhu — Wed, 20 Jun 2007 15:12:00 GMT

�q�看深圳像天堂，�q�看深圳像银行；��C��深圳像牢房，不如回家攄��?nbsp;
　　个个都说深圳好，个个都往深圳跑；深圳挣钱深圳花，哪有钞票寄回家�?
　　都说�q�里工资高，��x��没钱买牙膏；都说�q�里伙食好，青菜里面加青草�?
　　都说�q�里环境好，蟑螂蚂蚁四处跑；都说�q�里领班帅，个个�q�_��像锅盖�?
　　�q�年打工�q�年愁，天天加班像只��_��加班加点无报酬，天天挨骂无理由�?
　　��见老板低着��_��发了工资摇摇��_��C��月尾��发愁，不知何年才出头�?
　　�|�湖的美奻I��田的汉�Q�布吉街的痞子满街串�Q�南��q��花，西丽的草�Q�仙湖里的和��满街跑�?br> 华��L城的帅哥�Q�沙头角的狼�Q�皇岗到处是��氓�Q�老成都的饭，彭年的床�Q�岗厦的女生吓死郎�?br> 盐田的田�Q�大鹏湾的湾�Q�小梅沙的男奛_��疯颠。南头关的痴�Q�梅林关的怨，�|�湖关的情��G香港转�?br> ��永的夜�Ԍ��村ֲ�的�ؕ�Q�公明的奛_��没男伴。西乡的土，沙井的苦�Q�宝安的男�h心里��c�?br> 兛_��的偷,兛_��的抢深圳的治安没法讲

Xiao.Zhu 2007-06-20 23:12 发表评论

串口

Xiao.Zhu — Sat, 16 Jun 2007 15:25:00 GMT

无论那种操作方式�Q�一般都通过四个步骤来完成：
�Q?span>1�Q?打开串口

Win32�pȝ��把文件的概念�q�行了扩展。无论是文�g、通信讑֤�、命名管道、邮件槽、磁盘、还是控制台�Q�都是用API函数CreateFile来打开或创建的。该函数的原型�ؓ�Q?/span>

HANDLE CreateFile( LPCTSTR lpFileName,
                 DWORD dwDesiredAccess,
                DWORD dwShareMode,
               LPSECURITY_ATTRIBUTES lpSecurityAttributes,
               DWORD dwCreationDistribution,
               DWORD dwFlagsAndAttributes,
               HANDLE hTemplateFile);

· lpFileName�Q�将要打开的串口逻辑名，�?span>“COM1”�Q?/span>

· dwDesiredAccess�Q�指定串口访问的�c�d��Q�可以是��d��、写入或二者�ƈ列；

· dwShareMode�Q�指定共享属性，�׃��串口不能�׃�n�Q�该参数必须�|��ؓ0�Q?/span>

· lpSecurityAttributes�Q�引用安全性属性结构，�~�省��gؓNULL�Q?/span>

· dwCreationDistribution�Q�创建标志，对串口操作该参数必须�|��ؓOPEN_EXISTING�Q?/span>

· dwFlagsAndAttributes�Q�属性描�q�ͼ�用于指定该串口是否进行异步操作，该��gؓFILE_FLAG_OVERLAPPED�Q�表�C�Z��用异步的I/O�Q�该��gؓ0�Q�表�C�同�?span>I/O操作�Q?/span>

· hTemplateFile�Q�对串口而言该参数必��ȝ��?span>NULL�Q?/span>

同步I/O方式打开串口的示例代码：

HANDLE hCom; //全局变量�Q�串口句�?br>hCom=CreateFile("COM1",//COM1�?span>
   GENERIC_READ|GENERIC_WRITE, //允许��d��?span>
     0, //独占方式
       NULL,
     OPEN_EXISTING, //打开而不是创�?span>
     0, //同步方式
   NULL);
if(hCom==(HANDLE)-1)
{
         AfxMessageBox("打开COM��p�|!");
        return FALSE;
}
     return TRUE;

重叠I/O打开串口的示例代码：

HANDLE hCom; //全局变量�Q�串口句�?span>
hCom =CreateFile("COM1", //COM1�?span>
   GENERIC_READ|GENERIC_WRITE, //允许��d��?span>
        0, //独占方式
       NULL,
     OPEN_EXISTING, //打开而不是创�?span>
      FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重叠方式
      NULL);
if(hCom ==INVALID_HANDLE_VALUE)
{
          AfxMessageBox("打开COM��p�|!");
          return FALSE;
}
return TRUE;

�Q?span>2�Q��?a name=配置串口>配置串口

在打开通讯讑֤�句柄后，常常需要对串口�q�行一些初始化配置工作。这需要通过一�?span>DCB�l�构来进行�?span>DCB�l�构包含了诸如�L特率、数据位数、奇偶校验和停止位数�{�信息。在查询或配�|�串口的属性时�Q�都要用DCB�l�构来作为缓冲区�?span>
　　一般用CreateFile打开串口后，可以调用GetCommState函数来获取串口的初始配置。要修改串口的配�|�，应该先修�?span>DCB�l�构�Q�然后再调用SetCommState函数讄��串口�?span>
　　DCB�l�构包含了串口的各项参数讄��Q�下面仅介绍几个该结构常用的变量�Q?/span>

typedef struct _DCB{
………   //波特率，指定通信讑֤�的传输速率。这个成员可以是实际波特率值或者下面的帔R��g��一�Q?br>   DWORD BaudRate;
CBR_110�Q?br>CBR_300�Q?br>CBR_600�Q?br>CBR_1200�Q?br>CBR_2400�Q?span>
CBR_4800�Q?br>CBR_9600�Q?br>CBR_19200�Q?br>CBR_38400�Q?br>CBR_56000�Q?br>CBR_57600�Q?span>
CBR_115200�Q?span>
CBR_128000�Q?span>
CBR_256000�Q?span>
CBR_14400DWORD fParity; // 指定奇偶校验使能。若此成员�ؓ1�Q�允许奇偶校验检�?span>
…BYTE ByteSize; // 通信字节位数�Q?span>4�?BYTE
Parity; //指定奇偶校验�Ҏ��。此成员可以有下列��|��EVENPARITY 偶校�?span>     NOPARITY 无校�?span>MARKPARITY 标记校验   ODDPARITY 奇校�?span>BYTE
StopBits; //指定停止位的位数�?br>此成员可以有下列��|��
ONESTOPBIT 1位停止位
TWOSTOPBITS 2位停止位
ONE5STOPBITS   1.5位停止位   ……… } DCB;
winbase.h文�g中定义了以上用到的常量�?br>如下�Q?br>#define NOPARITY            0
#define ODDPARITY           1
#define EVENPARITY          2
#define ONESTOPBIT          0
#define ONE5STOPBITS        1
#define TWOSTOPBITS         2
#define CBR_110             110
#define CBR_300             300
#define CBR_600             600
#define CBR_1200            1200
#define CBR_2400            2400
#define CBR_4800            4800
#define CBR_9600            9600
#define CBR_14400           14400
#define CBR_19200           19200
#define CBR_38400           38400
#define CBR_56000           56000
#define CBR_57600           57600
#define CBR_115200          115200
#define CBR_128000          128000
#define CBR_256000          256000

GetCommState函数可以获得COM口的讑֤�控制块，从而获得相兛_��敎ͼ�

BOOL GetCommState( HANDLE hFile, //标识通讯端口的句�?span>
LPDCB lpDCB //指向一个设备控制块�Q?span>DCB�l�构�Q�的指针 );
SetCommState函数讄��COM口的讑֤�控制块：
BOOL SetCommState( HANDLE hFile, LPDCB lpDCB );

除了�?span>BCD中的讄��外，�E�序一般还需要设�|?span>I/O�~�冲区的大小和超时�?span>Windows�?span>I/O�~�冲区来暂存串口输入和输出的数据。如果通信的速率较高�Q�则应该讄��较大的缓冲区。调�?span>SetupComm函数可以讄��串行口的输入和输出缓冲区的大��?/span>

BOOL SetupComm(    HANDLE hFile,    // 通信讑֤�的句�?span>
DWORD dwInQueue, // 输入�~�冲区的大小�Q�字节数�Q?span>
DWORD dwOutQueue   // 输出�~�冲区的大小�Q�字节数�Q?span>   );

在用ReadFile�?span>WriteFile��d��串行口时�Q�需要考虑��时问题。超时的作用是在指定的时间内没有��d��或发送指定数量的字符�Q?span>ReadFile�?span>WriteFile的操作仍然会�l�束�?span>
　　要查询当前的��时讄��应调�?span>GetCommTimeouts函数�Q�该函数会填充一�?span>COMMTIMEOUTS�l�构。调�?span>SetCommTimeouts可以用某一�?span>COMMTIMEOUTS�l�构的内�Ҏ��讄��时�?span>
　　��d��串口的超时有两种�Q�间隔超时和总超时。间隔超时是指在接收时两个字�W�之间的最大时延。总超时是指读写操作��d��p��的最大时间。写操作只支持总超�Ӟ��而读操作两种��时均支持。用COMMTIMEOUTS�l�构可以规定��d��操作的超时�?span>
COMMTIMEOUTS�l�构的定义�ؓ�Q?/span>

typedef struct _COMMTIMEOUTS {
DWORD ReadIntervalTimeout; //读间隔超�?span>
DWORD ReadTotalTimeoutMultiplier; //��L��间系�?span>
DWORD ReadTotalTimeoutConstant; //��L��间常�?span>
DWORD WriteTotalTimeoutMultiplier; // 写时间系�?span>
DWORD WriteTotalTimeoutConstant; //写时间常�?span>
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

COMMTIMEOUTS�l�构的成员都以毫�U��ؓ单位。总超时的计算公式是：
总超�Ӟ��旉��p�L��×要求�?span>/写的字符敎ͼ�旉��帔R��
例如�Q�要��d��10个字�W�，那么��L��作的总超时的计算公式为：
��L��超�Ӟ��ReadTotalTimeoutMultiplier×10�Q?span>ReadTotalTimeoutConstant
可以看出�Q�间隔超时和总超时的讄��是不相关的，�q�可以方侉K��信�E�序灉|��地设�|�各�U�超时�?span>

如果所有写��时参数均�ؓ0�Q�那么就不��用写��时。如�?span>ReadIntervalTimeout�?span>0�Q�那么就不��用读间隔��时。如�?span>ReadTotalTimeoutMultiplier �?span> ReadTotalTimeoutConstant 都�ؓ0�Q�则不��用读总超时。如果读间隔��时被设�|�成MAXDWORD�q�且��L��间系数和��L��间常量都�?span>0�Q�那么在��M��ơ输入缓冲区的内容后��L��作就立即�q�回�Q�而不��是否读入了要求的字�W��?span>
　　在用重叠方式��d��串口�Ӟ��虽然ReadFile�?span>WriteFile在完成操作以前就可能�q�回�Q�但��时仍然是�v作用的。在�q�种情况下，��时规定的是操作的完成时��_��而不�?span>ReadFile�?span>WriteFile的返回时间�?span>
配置串口的示例代码：

SetupComm(hCom,1024,1024); //输入�~�冲区和输出�~�冲区的大小都是1024
COMMTIMEOUTS TimeOuts;     //讑֮�读超�?span>
TimeOuts.ReadIntervalTimeout=1000;
TimeOuts.ReadTotalTimeoutMultiplier=500;
TimeOuts.ReadTotalTimeoutConstant=5000;     //讑֮�写超�?span>   T
imeOuts.WriteTotalTimeoutMultiplier=500;
TimeOuts.WriteTotalTimeoutConstant=2000;
SetCommTimeouts(hCom,&TimeOuts); //讄��时
DCB dcb;
GetCommState(hCom,&dcb);
dcb.BaudRate=9600; //波特率�ؓ9600
dcb.ByteSize=8; //每个字节�?span>8�?span>
dcb.Parity=NOPARITY; //无奇偶校验位
dcb.StopBits=TWOSTOPBITS; //两个停止�?span>
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);

在读写串口之前，�q�要�?span>PurgeComm()函数清空�~�冲区，该函数原型：

BOOL PurgeComm( HANDLE hFile, //串口句柄
DWORD dwFlags // 需要完成的操作
);

参数dwFlags指定要完成的操作�Q�可以是下列值的�l�合�Q?/span>

PURGE_TXABORT 中断所有写操作�q�立卌��回，即��写操作还没有完成�?span>PURGE_RXABORT 中断所有读操作�q�立卌��回，即��L��作还没有完成�?span>PURGE_TXCLEAR 清除输出�~�冲�?span>PURGE_RXCLEAR 清除输入�~�冲�?/span>

�Q?span>3�Q��?a name=��d��串口>��d��串口

我们使用ReadFile�?span>WriteFile��d��串口�Q�下面是两个函数的声明：

BOOL ReadFile(    HANDLE hFile,     //串口的句�?span>        // ��d��的数据存储的地址�Q?span>    // 卌��入的数据��存储在以该指针的��gؓ首地址的一片内存区
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,       // 要读入的数据的字节数        // 指向一�?span>DWORD数��|��该数��D��回读操作实际��d��的字节数
LPDWORD lpNumberOfBytesRead,             // 重叠操作�Ӟ��该参数指向一�?span>OVERLAPPED�l�构�Q�同步操作时�Q�该参数�?span>NULL�?span>
LPOVERLAPPED lpOverlapped        );
BOOL WriteFile(    HANDLE hFile,      //串口的句�?span>            // 即以该指针的��gؓ首地址�?span>nNumberOfBytesToWrite    // 个字节的数据��要写入串口的发送数据缓冲区�?span>
LPCVOID lpBuffer,       // 写入的数据存储的地址�Q?/span>
DWORD nNumberOfBytesToWrite, //要写入的数据的字节数        // 指向指向一�?span>DWORD数��|��该数��D��回实际写入的字节�?span>
LPDWORD lpNumberOfBytesWritten,             // 重叠操作�Ӟ��该参数指向一�?span>OVERLAPPED�l�构�Q?span>    // 同步操作�Ӟ��该参��CؓNULL�?span>
LPOVERLAPPED lpOverlapped        );

在用ReadFile�?span>WriteFile��d��串口�Ӟ��既可以同步执行，也可以重叠执行。在同步执行�Ӟ��函数直到操作完成后才�q�回。这意味着同步执行时线�E�会被阻塞，从而导致效率下降。在重叠执行�Ӟ��即��操作�q�未完成�Q�这两个函数也会立即�q�回�Q�费时的I/O操作在后台进行�?span>
　　ReadFile�?span>WriteFile函数是同步还是异步由CreateFile函数军_��Q�如果在调用CreateFile创徏句柄时指定了FILE_FLAG_OVERLAPPED标志�Q�那么调�?span>ReadFile�?span>WriteFile对该句柄�q�行的操作就应该是重叠的�Q�如果未指定重叠标志�Q�则��d��操作应该是同步的�?span>ReadFile�?span>WriteFile函数的同步或者异步应该和CreateFile函数�怸�致�?span>
　　ReadFile函数只要在串口输入缓冲区中读入指定数量的字符�Q�就��完成操作。�?span>WriteFile函数不但要把指定数量的字�W�拷入到输出�~�冲区，而且要等�q�些字符从串行口送出��d��才算完成操作�?span>
　　如果操作成功�Q�这两个函数都返�?span>TRUE。需要注意的是，�?span>ReadFile�?span>WriteFile�q�回FALSE�Ӟ��不一定就是操作失败，�U�程应该调用GetLastError函数分析�q�回的结果。例如，在重叠操作时如果操作�q�未完成函数��p��回，那么函数��p��?span>FALSE�Q�而且GetLastError函数�q�回ERROR_IO_PENDING。这说明重叠操作�q�未完成�?span>

同步方式��d��串口比较��单，下面先例丑֐�步方式读写串口的代码�Q?/span>

//同步��M��?span>char str[100];
DWORD wCount;//��d��的字节数
BOOL bReadStat;
bReadStat=ReadFile(hCom,str,100,&wCount,NULL);
if(!bReadStat){
AfxMessageBox("��M��口失�?span>!");
return FALSE;
}
return TRUE;
//同步写串�?span>
char lpOutBuffer[100];
DWORD dwBytesWrite=100;
COMSTAT ComStat;
DWORD dwErrorFlags;
BOOL bWriteStat;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
bWriteStat=WriteFile(hCom,lpOutBuffer,dwBytesWrite,& dwBytesWrite,NULL);
if(!bWriteStat) {
             AfxMessageBox("写串口失�?span>!");
}
PurgeComm(hCom, PURGE_TXABORT|              PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);

在重叠操作时,操作�q�未完成函数��p��回�?span>

　　重叠I/O非常灉|��Q�它也可以实现阻塞（例如我们可以讄��一定要��d��C��个数据才能进行到下一步操作）。有两种�Ҏ��可以�{�待操作完成�Q�一�U�方法是用象WaitForSingleObject�q�样的等待函数来�{�待OVERLAPPED�l�构�?span>hEvent成员�Q�另一�U�方法是调用GetOverlappedResult函数�{�待�Q�后面将演示说明�?span>
下面我们先简单说一�?span>OVERLAPPED�l�构�?span>GetOverlappedResult函数�Q?span>
OVERLAPPED�l�构
OVERLAPPED�l�构包含了重�?span>I/O的一些信息，定义如下�Q?/span>

typedef struct _OVERLAPPED { // o DWORD Internal; DWORD InternalHigh; DWORD Offset; DWORD OffsetHigh; HANDLE hEvent; } OVERLAPPED;

在��?span>ReadFile�?span>WriteFile重叠操作�Ӟ��U�程需要创�?span>OVERLAPPED�l�构以供�q�两个函��C��用。线�E�通过OVERLAPPED�l�构获得当前的操作状态，该结构最重要的成员是hEvent�?span>hEvent是读写事件。当串口使用异步通讯�Ӟ��函数�q�回时操作可能还没有完成�Q�程序可以通过��查该事�g得知是否��d��完毕�?span>
　　当调�?span>ReadFile, WriteFile 函数的时候，该成员会自动被置为无信号状态；当重叠操作完成后�Q�该成员变量会自动被�|��ؓ有信��L��态�?/span>

GetOverlappedResult函数BOOL GetOverlappedResult( HANDLE hFile, // 串口的句�?span> // 指向重叠操作开始时指定�?span>OVERLAPPED�l�构 LPOVERLAPPED lpOverlapped, // 指向一�?span>32位变量，该变量的��D��回实际读写操作传输的字节数�?span> LPDWORD lpNumberOfBytesTransferred, // 该参数用于指定函数是否一直等到重叠操作结束�?span> // 如果该参��CؓTRUE�Q�函数直到操作结束才�q�回�?span> // 如果该参��CؓFALSE�Q�函数直接返回，�q�时如果操作没有完成�Q?span> // 通过调用GetLastError()函数会返�?span>ERROR_IO_INCOMPLETE�?span> BOOL bWait );

该函数返回重叠操作的�l�果�Q�用来判断异步操作是否完成，它是通过判断OVERLAPPED�l�构中的hEvent是否被置位来实现的�?span>

异步��M��口的�C�Z��代码�Q?/span>

char lpInBuffer[1024];
DWORD dwBytesRead=1024;
COMSTAT ComStat;
DWORD dwErrorFlags;
OVERLAPPED m_osRead;
memset(&m_osRead,0,sizeof(OVERLAPPED));
m_osRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
ClearCommError(hCom,&dwErrorFlags,&ComStat);
dwBytesRead=min(dwBytesRead,(DWORD)ComStat.cbInQue);
if(!dwBytesRead)
return FALSE;
BOOL bReadStatus;
bReadStatus=ReadFile(hCom,
lpInBuffer,
dwBytesRead,
&dwBytesRead,
&m_osRead);
if(!bReadStatus) //如果ReadFile函数�q�回FALSE
{
if(GetLastError()==ERROR_IO_PENDING) //GetLastError()函数�q�回ERROR_IO_PENDING,表明串口正在�q�行��L��?span>
{
WaitForSingleObject(m_osRead.hEvent,2000);         //使用WaitForSingleObject函数�{�待�Q�直到读操作完成或�g时已辑ֈ�2�U�钟        //当串口读操作�q�行完毕后，m_osRead�?span>hEvent事�g会变为有信号
PurgeComm(hCom, PURGE_TXABORT|                      PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
      return dwBytesRead;
}
return 0;
}
PurgeComm(hCom, PURGE_TXABORT|              PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
return dwBytesRead;

对以上代码再作简要说明：在��?span>ReadFile 函数�q�行��L��作前�Q�应先��?span>ClearCommError函数清除错误�?span>ClearCommError函数的原型如下：

BOOL ClearCommError(    HANDLE hFile,      // 串口句柄
LPDWORD lpErrors,      // 指向接收错误码的变量
LPCOMSTAT lpStat // 指向通讯状态缓冲区
);

该函数获得通信错误�q�报告串口的当前状态，同时�Q�该函数清除串口的错误标志以便��l�输入、输出操作�?span>
参数lpStat指向一�?span>COMSTAT�l�构�Q�该�l�构�q�回串口状态信息�?span> COMSTAT�l�构 COMSTAT�l�构包含串口的信息，�l�构定义如下�Q?/span>

typedef struct _COMSTAT { // cst
DWORD fCtsHold : 1; // Tx waiting for CTS signal
DWORD fDsrHold : 1;   // Tx waiting for DSR signal
DWORD fRlsdHold : 1; // Tx waiting for RLSD signal
DWORD fXoffHold : 1; // Tx waiting, XOFF char rec''d
DWORD fXoffSent : 1; // Tx waiting, XOFF char sent
DWORD fEof : 1;       // EOF character sent
DWORD fTxim : 1;      // character waiting for Tx
DWORD fReserved : 25; // reserved
DWORD cbInQue;        // bytes in input buffer
DWORD cbOutQue;       // bytes in output buffer
} COMSTAT, *LPCOMSTAT;

本文只用��C��cbInQue成员变量�Q�该成员变量的��g��表输入缓冲区的字节数�?span>

　　最后用PurgeComm函数清空串口的输入输出缓冲区�?/span>

�q�段代码�?span>WaitForSingleObject函数来等�?span>OVERLAPPED�l�构�?span>hEvent成员�Q�下面我们再演示一�D�调�?span>GetOverlappedResult函数�{�待的异步读串口�C�Z��代码�Q?/span>

char lpInBuffer[1024];
DWORD dwBytesRead=1024;
BOOL bReadStatus;
DWORD dwErrorFlags;
COMSTAT ComStat;
OVERLAPPED m_osRead;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
if(!ComStat.cbInQue)           return 0;
dwBytesRead=min(dwBytesRead,(DWORD)ComStat.cbInQue);
bReadStatus=ReadFile(hCom,
lpInBuffer,
dwBytesRead,
&dwBytesRead,
&m_osRead);
if(!bReadStatus) //如果ReadFile函数�q�回FALSE
{
if(GetLastError()==ERROR_IO_PENDING)
{
GetOverlappedResult(hCom,
&m_osRead,&dwBytesRead,TRUE);           // GetOverlappedResult函数的最后一个参数设�?span>TRUE�Q?span>           //函数会一直等待，直到��L��作完成或�׃��错误而返回�?span>                   return dwBytesRead;
}
return 0;
}
return dwBytesRead;

异步写串口的�C�Z��代码�Q?/span>

char buffer[1024];
DWORD dwBytesWritten=1024;
DWORD dwErrorFlags;
COMSTAT ComStat;
OVERLAPPED m_osWrite;
BOOL bWriteStat;
bWriteStat=WriteFile(hCom,buffer,dwBytesWritten,           &dwBytesWritten,&m_OsWrite);
if(!bWriteStat) {
if(GetLastError()==ERROR_IO_PENDING)
{
WaitForSingleObject(m_osWrite.hEvent,1000);
return dwBytesWritten;
}
return 0;
}
return dwBytesWritten;

�Q?span>4�Q��?a name=关闭串口>关闭串口

利用API函数关闭串口非常��单，只需使用CreateFile函数�q�回的句柄作为参数调�?span>CloseHandle卛_��Q?/span>

BOOL CloseHandle( HANDLE hObject; //handle to object to close );

串口�~�程的一个实�?/span>

��Z��让您更好地理解串口编�E?span>,下面我们分别�~�写两个例程�Q�见附带的源码部分）,�q�两个例�E�都实现了工控机与百�Ҏ��C�Z�A表通过RS485接口�q�行的串口通信。其中第一个例�E�采用同步串口操�?span>,�W�二个例�E�采用异步串口操作�?span>
　　我们只介�l��Y仉��分，RS485接口接线�Ҏ��不作介绍�Q�感兴趣的读者可以查阅相兌��料�?/span>

例程1

打开VC++6.0�Q�新建基于对话框的工�E?span>RS485Comm�Q�在��d��话框�H�口IDD_RS485COMM_DIALOG上添加两个按钮，ID分别�?span>IDC_SEND�?span>IDC_RECEIVE�Q�标题分别�ؓ“发�?span>”�?span>“接收”�Q�添加一个静态文本框IDC_DISP�Q�用于显�C�Z��口接收到的内宏V�?span>

�?span>RS485CommDlg.cpp文�g中添加全局变量�Q?/span>

HANDLE hCom; //全局变量�Q�串口句�?/span>

�?span>RS485CommDlg.cpp文�g中的OnInitDialog()函数��d��如下代码�Q?/span>

// TODO: Add extra initialization here
hCom=CreateFile("COM1",//COM1�?span>
GENERIC_READ|GENERIC_WRITE, //允许��d��?span>
0, //独占方式
NULL,
OPEN_EXISTING, //打开而不是创�?span>
0, //同步方式
NULL);
if(hCom==(HANDLE)-1)
{
AfxMessageBox("打开COM��p�|!");
return FALSE;
}
SetupComm(hCom,100,100); //输入�~�冲区和输出�~�冲区的大小都是1024
COMMTIMEOUTS TimeOuts; //讑֮�读超�?span>
TimeOuts.ReadIntervalTimeout=MAXDWORD;
TimeOuts.ReadTotalTimeoutMultiplier=0;
TimeOuts.ReadTotalTimeoutConstant=0;     //在读一�ơ输入缓冲区的内容后��L��作就立即�q�回�Q?span>        //而不��是否读入了要求的字�W��?span>     //讑֮�写超�?span>   TimeOuts.WriteTotalTimeoutMultiplier=100;
TimeOuts.WriteTotalTimeoutConstant=500;
SetCommTimeouts(hCom,&TimeOuts); //讄��时
DCB dcb;
GetCommState(hCom,&dcb);
dcb.BaudRate=9600; //波特率�ؓ9600
dcb.ByteSize=8; //每个字节�?span>8�?span>
dcb.Parity=NOPARITY; //无奇偶校验位
dcb.StopBits=TWOSTOPBITS; //两个停止�?span>
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);

分别双击IDC_SEND按钮�?span>IDC_RECEIVE按钮�Q�添加两个按钮的响应函数�Q?/span>

void CRS485CommDlg::OnSend() {
// TODO: Add your control notification handler code here
// 在此需要简单介�l�百特公�?span>XMA5000的通讯协议�Q?span>
//该��A�?span>RS485通讯采用��L��q�播方式通讯�?span>
//串行半双工，�?span>11位，1个�v始位(0)�Q?span>8个数据位�Q?span>2个停止位(1)
//如：��M�A表显�C�的瞬时��|��L��发送：DC1 AAA BB ETX
//其中�Q?span>DC1是标�?span>ASCII码的一个控制符��P��码��gؓ11H(十进制的17)
//�?span>XMA5000的通讯协议中，DC1表示�ȝ��时�?span>
//AAA是从机地址码，也就�?span>XMA5000昄��仪表的通讯地址
//BB为通道��P��ȝ��时值时该��gؓ01
//ETX也是标准ASCII码的一个控制符��P��码��gؓ03H
//�?span>XMA5000的通讯协议中，ETX表示��L��l�束�W?span>
char lpOutBuffer[7];
memset(lpOutBuffer,''\0'',7); //�?span>7个字节先清零     l
pOutBuffer[0]=''\x11''; //发送缓冲区的第1个字节�ؓDC1
lpOutBuffer[1]=''0''; //�W?span>2个字节�ؓ字符0(30H)
lpOutBuffer[2]=''0''; //�W?span>3个字节�ؓ字符0(30H)
lpOutBuffer[3]=''1''; // �W?span>4个字节�ؓ字符1(31H)
lpOutBuffer[4]=''0''; //�W?span>5个字节�ؓ字符0(30H)
lpOutBuffer[5]=''1''; //�W?span>6个字节�ؓ字符1(31H)
lpOutBuffer[6]=''\x03''; //�W?span>7个字节�ؓ字符ETX       //从该�D�代码可以看出，仪表的通讯地址�?span>001
DWORD dwBytesWrite=7;
COMSTAT ComStat;
DWORD dwErrorFlags;
BOOL bWriteStat;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
bWriteStat=WriteFile(hCom,lpOutBuffer,dwBytesWrite,& dwBytesWrite,NULL);
if(!bWriteStat) {
AfxMessageBox("写串口失�?span>!");
}
}
void CRS485CommDlg::OnReceive() {
// TODO: Add your control notification handler code here
char str[100];
memset(str,''\0'',100);
DWORD wCount=100;//��d��的字节数
BOOL bReadStat;
bReadStat=ReadFile(hCom,str,wCount,&wCount,NULL);
if(!bReadStat)
AfxMessageBox("��M��口失�?span>!");
PurgeComm(hCom, PURGE_TXABORT|      PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
m_disp=str;
UpdateData(FALSE);
}

您可以观察返回的字符�Ԍ��其中有和仪表昄��值相同的部分�Q�您可以�q�行相应的字�W�串操作取出仪表的显�C�倹{�?span>
打开ClassWizard,为静态文本框IDC_DISP��d��CString�c�d��变量m_disp�Q�同时添�?span>WM_CLOSE的相应函敎ͼ�

void CRS485CommDlg::OnClose() {
// TODO: Add your message handler code here and/or call default
CloseHandle(hCom);       //�E�序退出时关闭串口
CDialog::OnClose();
}

�E�序的相应部分已�l�在代码内部作了详细介绍。连接好��g部分�Q�编译运行程序，�l�心体会串口同步操作部分�?/span>

例程2

打开VC++6.0�Q�新建基于对话框的工�E?span>RS485Comm�Q�在��d��话框�H�口IDD_RS485COMM_DIALOG上添加两个按钮，ID分别�?span>IDC_SEND�?span>IDC_RECEIVE�Q�标题分别�ؓ“发�?span>”�?span>“接收”�Q�添加一个静态文本框IDC_DISP�Q�用于显�C�Z��口接收到的内宏V��在RS485CommDlg.cpp文�g中添加全局变量�Q?/span>

HANDLE hCom; //全局变量�Q?/span>

串口句柄�?span>RS485CommDlg.cpp文�g中的OnInitDialog()函数��d��如下代码�Q?/span>

hCom=CreateFile("COM1",//COM1�?span>
GENERIC_READ|GENERIC_WRITE, //允许��d��?span>
0, //独占方式
NULL,
OPEN_EXISTING, //打开而不是创�?span>
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重叠方式
NULL);
if(hCom==(HANDLE)-1)   {
AfxMessageBox("打开COM��p�|!");
return FALSE;
}
SetupComm(hCom,100,100); //输入�~�冲区和输出�~�冲区的大小都是100
COMMTIMEOUTS TimeOuts; //讑֮�读超�?span>
TimeOuts.ReadIntervalTimeout=MAXDWORD;
TimeOuts.ReadTotalTimeoutMultiplier=0;
TimeOuts.ReadTotalTimeoutConstant=0;     //在读一�ơ输入缓冲区的内容后��L��作就立即�q�回�Q?span>        //而不��是否读入了要求的字�W��?span>     //讑֮�写超�?span>   TimeOuts.WriteTotalTimeoutMultiplier=100;
TimeOuts.WriteTotalTimeoutConstant=500;
SetCommTimeouts(hCom,&TimeOuts); //讄��时
DCB dcb;
GetCommState(hCom,&dcb);
dcb.BaudRate=9600; //波特率�ؓ9600
dcb.ByteSize=8; //每个字节�?span>8�?span>
dcb.Parity=NOPARITY; //无奇偶校验位
dcb.StopBits=TWOSTOPBITS; //两个停止�?span>
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);

分别双击IDC_SEND按钮�?span>IDC_RECEIVE按钮�Q�添加两个按钮的响应函数�Q?/span>

void CRS485CommDlg::OnSend() {
// TODO: Add your control notification handler code here
OVERLAPPED m_osWrite;
memset(&m_osWrite,0,sizeof(OVERLAPPED));
    m_osWrite.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
char lpOutBuffer[7];
memset(lpOutBuffer,''\0'',7);
lpOutBuffer[0]=''\x11'';
lpOutBuffer[1]=''0'';
lpOutBuffer[2]=''0'';
lpOutBuffer[3]=''1'';
lpOutBuffer[4]=''0'';
lpOutBuffer[5]=''1'';
lpOutBuffer[6]=''\x03'';
DWORD dwBytesWrite=7;
COMSTAT ComStat;
DWORD dwErrorFlags;
BOOL bWriteStat;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
bWriteStat=WriteFile(hCom,lpOutBuffer,      dwBytesWrite,& dwBytesWrite,&m_osWrite);
if(!bWriteStat) {
if(GetLastError()==ERROR_IO_PENDING)
{
WaitForSingleObject(m_osWrite.hEvent,1000);
}
}
}
void CRS485CommDlg::OnReceive()
{
// TODO: Add your control notification handler code here
OVERLAPPED m_osRead;
memset(&m_osRead,0,sizeof(OVERLAPPED));
m_osRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
COMSTAT ComStat;
DWORD dwErrorFlags;
char str[100]; memset(str,''\0'',100);
DWORD dwBytesRead=100;//��d��的字节数
BOOL bReadStat;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
dwBytesRead=min(dwBytesRead, (DWORD)ComStat.cbInQue);
bReadStat=ReadFile(hCom,str,        dwBytesRead,&dwBytesRead,&m_osRead);
if(!bReadStat) {
if(GetLastError()==ERROR_IO_PENDING)     //GetLastError()函数�q�回ERROR_IO_PENDING,表明串口正在�q�行��L��?span>
{
WaitForSingleObject(m_osRead.hEvent,2000);                //使用WaitForSingleObject函数�{�待�Q�直到读操作完成或�g时已辑ֈ�2�U�钟               //当串口读操作�q�行完毕后，m_osRead�?span>hEvent事�g会变为有信号
}
}
PurgeComm(hCom, PURGE_TXABORT|      PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
m_disp=str;
UpdateData(FALSE);
}

打开ClassWizard,为静态文本框IDC_DISP��d��CString�c�d��变量m_disp�Q�同时添�?span>WM_CLOSE的相应函敎ͼ�

void CRS485CommDlg::OnClose() {
// TODO: Add your message handler code here and/or call default
CloseHandle(hCom);       //�E�序退出时关闭串口
CDialog::OnClose();
}

Xiao.Zhu 2007-06-16 23:25 发表评论

Windows Sockets 2.0:使用完成端口高性能�Q�可扩展性Winsock服务�E�序 (�?

Xiao.Zhu — Fri, 18 May 2007 01:52:00 GMT

摘要: Windows Sockets 2.0:使用完成端口高性能�Q�可扩展性Winsock服务�E�序阅读全文

Xiao.Zhu 2007-05-18 09:52 发表评论