[转帖]想成为嵌入式程序员应知道的16个基本问题

[转帖]想成为嵌入式程序员应知道的16个基本问题

　　这是嵌入式C程序员的基本知识。作者在Embedded Systems Programming杂志上发表了很多嵌入式系统开发方面的文章。

　　C语言测试是招聘嵌入式系统程序员过程中必须而且有效的方法。这些年，我既参加也组织了许多这种测试，在这过程中我意识到这些测试能为面试者和被面试者提供许多有用信息，此外，撇开面试的压力不谈，这种测试也是相当有趣的。
　 　从被面试者的角度来讲，你能了解许多关于出题者或监考者的情况。这个测试只是出题者为显示其对ANSI标准细节的知识而不是技术技巧而设计吗？这是个愚 蠢的问题吗？如要你答出某个字符的ASCII值。这些问题着重考察你的系统调用和内存分配策略方面的能力吗？这标志着出题者也许花时间在微机上而不是在嵌 入式系统上。如果上述任何问题的答案是"是"的话，那么我知道我得认真考虑我是否应该去做这份工作。
从面试者的角度来讲，一个测试也许能从多方面 揭示应试者的素质：最基本的，你能了解应试者C语言的水平。不管怎么样，看一下这人如何回答他不会的问题也是满有趣。应试者是以好的直觉做出明智的选择， 还是只是瞎蒙呢？当应试者在某个问题上卡住时是找借口呢，还是表现出对问题的真正的好奇心，把这看成学习的机会呢？我发现这些信息与他们的测试成绩一样有 用。
　　有了这些想法，我决定出一些真正针对嵌入式系统的考题，希望这些令人头痛的考题能给正在找工作的人一点帮助。这些问题都是我这些年实际碰到的。其中有些题很难，但它们应该都能给你一点启迪。
这个测试适于不同水平的应试者，大多数初级水平的应试者的成绩会很差，经验丰富的程序员应该有很好的成绩。为了让你能自己决定某些问题的偏好，每个问题没有分配分数，如果选择这些考题为你所用，请自行按你的意思分配分数。

预处理器（Preprocessor）

1 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
1) #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。

2 . 写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个。
#define MIN(A,B) （（A） <= (B) ? (A) : (B))
这个测试是为下面的目的而设的：
1) 标识#define在宏中应用的基本知识。这是很重要的。因为在 嵌入(inline)操作符 变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。
2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。
3) 懂得在宏中小心地把参数用括号括起来
4) 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？
least = MIN(*p++, b);

3. 预处理器标识#error的目的是什么？
　　如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。

死循环（Infinite loops）

4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？
这个问题用几个解决方案。我首选的方案是：

while(1)
{

}

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

for(;;)
{

}

　　这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的基本原理。如果他们的基本答案是："我被教着这样做，但从没有想到过为什么。"这会给我留下一个坏印象。

第三个方案是用 goto
Loop:
...
goto Loop;
　　应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。

数据声明（Data declarations）

5. 用变量a给出下面的定义
a) 一个整型数（An integer）
b)一个指向整型数的指针（ A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
d)一个有10个整型数的数组（ An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（ 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) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）

答案是：
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

　 　人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被 面试的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案（或至少大部 分答案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么做出准备呢？

Static

6. 关键字static的作用是什么？
这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

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

Const

7．关键字const有什么含意？
　 　我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可 以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
　　如果应试者能正确回答这个问题，我将问他一个附加的问题：
下面的声明都是什么意思？

const int a;
int const a;
const int *a;
int * const a;
int const * a const;

/******/
　 　前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向 整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整 型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键 字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理 其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

Volatile

8. 关键字volatile有什么含意?并给出三个不同的例子。
　　一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
1) 并行设备的硬件寄存器（如：状态寄存器）
2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3) 多线程应用中被几个任务共享的变量

　　回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。
　　假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1)一个参数既可以是const还可以是volatile吗？解释为什么。
2); 一个指针可以是volatile 吗？解释为什么。
3); 下面的函数有什么错误：

int square(volatile int *ptr)
{
return *ptr * *ptr;
}

下面是答案：
1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2); 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3) 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}

　　由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}

位操作（Bit manipulation）

9. 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。
对这个问题有三种基本的反应
1)不知道如何下手。该被面者从没做过任何嵌入式系统的工作。
2) 用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序，它用到了bit fields因此完全对我无用，因为我的编译器用其它的方式来实现bit fields的。从道德讲：永远不要让一个非嵌入式的家伙粘实际硬件的边。
3) 用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：

#define BIT3 (0x1 << 3)
static int a;

void set_bit3(void)
{
a |= BIT3;
}
void clear_bit3(void)
{
a &= ~BIT3;
}

　　一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数，这也是可以接受的。我希望看到几个要点：说明常数、|=和&=~操作。

访问固定的内存位置（Accessing fixed memory locations）

10. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。
这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;

A more obscure approach is:
一个较晦涩的方法是：

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

即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。

中断（Interrupts）

11. 中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。

__interrupt double compute_area (double radius)
{
double area = PI * radius * radius;
printf("nArea = %f", area);
return area;
}

这个函数有太多的错误了，以至让人不知从何说起了：
1)ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。
2) ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。
3) 在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。
4) 与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。

代码例子（Code examples）

12 . 下面的代码输出是什么，为什么？

void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
　 　这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式 计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

13. 评价下面的代码片断：

unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
/*1's complement of zero */

对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：

unsigned int compzero = ~0;

　　这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。
到 了这个阶段，应试者或者完全垂头丧气了或者信心满满志在必得。如果显然应试者不是很好，那么这个测试就在这里结束了。但如果显然应试者做得不错，那么我就 扔出下面的追加问题，这些问题是比较难的，我想仅仅非常优秀的应试者能做得不错。提出这些问题，我希望更多看到应试者应付问题的方法，而不是答案。不管如 何，你就当是这个娱乐吧...

动态内存分配（Dynamic memory allocation）

14. 尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？
这 里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J. Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：
下面的代码片段的输出是什么，为什么？

char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");

　 　这是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc，得到了一个合法的指针之后，我才想到这个问题。这就是上面的代码，该代码 的输出是"Got a valid pointer"。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基 本原理更重要些。

Typedef

15 Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：

#define dPS struct s *
typedef struct s * tPS;

　　以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：

dPS p1,p2;
tPS p3,p4;

第一个扩展为

struct s * p1, p2;
.
　　上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

 

晦涩的语法

16 . C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？

int a = 5, b = 7, c;
c = a+++b;

　　这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：

c = a++ + b;

因此, 这段代码持行后a = 6, b = 7, c = 12。
　　如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题。

　　好了，伙计们，你现在已经做完所有的测试了。这就是我出的C语言测试题，我怀着愉快的心情写完它，希望你以同样的心情读完它。如果是认为这是一个好的测试，那么尽量都用到你的找工作的过程中去吧。天知道也许过个一两年，我就不做现在的工作，也需要找一个。

参考文献
1) Jones, Nigel, "In Praise of the #error directive," Embedded Systems Programming, September 1999, p. 114.
2) Jones, Nigel, " Efficient C Code for Eight-bit MCUs ," Embedded Systems Programming, November 1998, p. 66.
 

如何优化C语言代码(程序员必读)
AlexanderWu 发表于2006 2月, 11 12:37 [C资料库]

1、选择合适的算法和数据结构
应该熟悉算法语言，知道各种算法的优缺点，具体资料请参见相应的参考资料，有
很多计算机书籍上都有介绍。将比较慢的顺序查找法用较快的二分查找或乱序查找
法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大
提高程序执行的效率。.选择一种合适的数据结构也很重要，比如你在一堆随机存
放的数中使用了大量的插入和删除指令，那使用链表要快得多。
数组与指针语句具有十分密码的关系，一般来说，指针比较灵活简洁，而数组则比
较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，
执行效率更高。但是在Keil中则相反，使用数组比使用的指针生成的代码更短。。

3、使用尽量小的数据类型
能够使用字符型(char)定义的变量，就不要使用整型(int)变量来定义；能够使用
整型变量定义的变量就不要用长整型(long int)，能不使用浮点型(float)变量就
不要使用浮点型变量。当然，在定义变量后不要超过变量的作用范围，如果超过变
量的范围赋值，C编译器并不报错，但程序运行结果却错了，而且这样的错误很难
发现。
在ICCAVR中，可以在Options中设定使用printf参数，尽量使用基本型参数(%c、
%d、%x、%X、%u和%s格式说明符)，少用长整型参数(%ld、%lu、%lx和%lX格式说明
符)，至于浮点型的参数(%f)则尽量不要使用，其它C编译器也一样。在其它条件不
变的情况下，使用%f参数，会使生成的代码的数量增加很多，执行速度降低。

4、使用自加、自减指令
通常使用自加、自减指令和复合赋值表达式(如a-=1及a+=1等)都能够生成高质量的
程序代码，编译器通常都能够生成inc和dec之类的指令，而使用a=a+1或a=a-1之类
的指令，有很多C编译器都会生成二到三个字节的指令。在AVR单片适用的ICCAVR、
GCCAVR、IAR等C编译器以上几种书写方式生成的代码是一样的，也能够生成高质量
的inc和dec之类的的代码。

5、减少运算的强度
可以使用运算量小但功能相同的表达式替换原来复杂的的表达式。如下：
(1)、求余运算。
a=a%8;
可以改为：
a=a&7;
说明：位操作只需一个指令周期即可完成，而大部分的C编译器的“%”运算均是调
用子程序来完成，代码长、执行速度慢。通常，只要求是求2n方的余数，均可使用
位操作的方法来代替。

(2)、平方运算
a=pow(a,2.0);
可以改为：
a=a*a;
说明：在有内置硬件乘法器的单片机中(如51系列)，乘法运算比求平方运算快得多
，因为浮点数的求平方是通过调用子程序来实现的，在自带硬件乘法器的AVR单片
机中，如ATMega163中，乘法运算只需2个时钟周期就可以完成。既使是在没有内置
硬件乘法器的AVR单片机中，乘法运算的子程序比平方运算的子程序代码短，执行
速度快。
如果是求3次方，如：
a=pow(a,3.0);
更改为：
a=a*a*a；
则效率的改善更明显。

(3)、用移位实现乘除法运算
a=a*4;
b=b/4;
可以改为：
a=a<<2;
b=b>>2;
说明：通常如果需要乘以或除以2n，都可以用移位的方法代替。在ICCAVR中，如果
乘以2n，都可以生成左移的代码，而乘以其它的整数或除以任何数，均调用乘除法
子程序。用移位的方法得到代码比调用乘除法子程序生成的代码效率高。实际上，
只要是乘以或除以一个整数，均可以用移位的方法得到结果，如：
a=a*9
可以改为：
a=(a<<3)+a

6、循环
(1)、循环语
对于一些不需要循环变量参加运算的任务可以把它们放到循环外面，这里的任务包
括表达式、函数的调用、指针运算、数组访问等，应该将没有必要执行多次的操作
全部集合在一起，放到一个init的初始化程序中进行。

(2)、延时函数：
通常使用的延时函数均采用自加的形式：
void delay (void)
{
unsigned int i;
for (i=0;i<1000;i++)
;
}
将其改为自减延时函数：
void delay (void)
{
unsigned int i;
for (i=1000;i>0;i--)
;
}
两个函数的延时效果相似，但几乎所有的C编译对后一种函数生成的代码均比前一
种代码少1~3个字节，因为几乎所有的MCU均有为0转移的指令，采用后一种方式能
够生成这类指令。
在使用while循环时也一样，使用自减指令控制循环会比使用自加指令控制循环生
成的代码更少1~3个字母。
但是在循环中有通过循环变量“i”读写数组的指令时，使用预减循环时有可能使
数组超界，要引起注意。

(3)while循环和do…while循环
用while循环时有以下两种循环形式：
unsigned int i;
i=0;
while (i<1000)
{
i++;
//用户程序
}
或：
unsigned int i;
i=1000;
do
i--;
//用户程序
while (i>0);
在这两种循环中，使用do…while循环编译后生成的代码的长度短于while循环。

7、查表
在程序中一般不进行非常复杂的运算，如浮点数的乘除及开方等，以及一些复杂的
数学模型的插补运算，对这些即消耗时间又消费资源的运算，应尽量使用查表的方
式，并且将数据表置于程序存储区。如果直接生成所需的表比较困难，也尽量在启
了，减少了程序执行过程中重复计算的工作量。

8、其它
比如使用在线汇编及将字符串和一些常量保存在程序存储器中，均有利于优化
 

-- C语言的文件操作
文件的基本概念
　 　所谓“文件”是指一组相关数据的有序集合。 这个数据集有一个名称，叫做文件名。 实际上在前面的各章中我们已经多次使用了文件，例如源程序文件、目标文件、可执行文件、库文件 (头文件)等。文件通常是驻留在外部介质(如磁盘等)上的， 在使用时才调入内存中来。从不同的角度可对文件作不同的分类。从用户的角度看，文件可分为普通文件和设备文件两种。

　　普通文件是指驻留在磁盘或其它外部介质上的一个有序数据集，可以是源文件、目标文件、可执行程序； 也可以是一组待输入处理的原始数据，或者是一组输出的结果。对于源文件、目标文件、 可执行程序可以称作程序文件，对输入输出数据可称作数据文件。

　 　设备文件是指与主机相联的各种外部设备，如显示器、打印机、键盘等。在操作系统中，把外部设备也看作是一个文件来进行管理，把它们的输入、输出等同于对 磁盘文件的读和写。 通常把显示器定义为标准输出文件， 一般情况下在屏幕上显示有关信息就是向标准输出文件输出。如前面经常使用的printf,putchar 函数就是这类输出。键盘通常被指定标准的输入文件， 从键盘上输入就意味着从标准输入文件上输入数据。scanf,getchar函数就属于这类输入。

　　从文件编码的方式来看，文件可分为ASCII码文件和二进制码文件两种。

　　ASCII文件也称为文本文件，这种文件在磁盘中存放时每个字符对应一个字节，用于存放对应的ASCII码。例如，数5678的存储形式为：
ASC码： 　00110101 00110110 00110111 00111000
　　　　　↓ 　　　　↓　　　　↓ 　　　↓
十进制码： 5　　　　　6　　　　7　　　　8 共占用4个字节。ASCII码文件可在屏幕上按字符显示， 例如源程序文件就是ASCII文件，用DOS命令TYPE可显示文件的内容。 由于是按字符显示，因此能读懂文件内容。

　 　二进制文件是按二进制的编码方式来存放文件的。 例如， 数5678的存储形式为： 00010110 00101110只占二个字节。二进制文件虽然也可在屏幕上显示， 但其内容无法读懂。C系统在处理这些文件时，并不区分类型，都看成是字符流，按字节进行处理。 输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。 因此也把这种文件称作“流式文件”。

　　本章讨论流式文件的 打开、关闭、读、写、 定位等各种操作。文件指针在Ｃ语言中用一个指针变量指向一个文件， 这个指针称为文件指针。通过文件指针就可对它所指的文件进行各种操作。 定义说明文件指针的一般形式为： FILE* 指针变量标识符； 其中FILE应为大写，它实际上是由系统定义的一个结构， 该结构中含有文件名、文件状态和文件当前位置等信息。 在编写源程序时不必关心FILE结构的细节。例如：FILE *fp； 表示fp是指向FILE结构的指针变量，通过fp 即可找存放某个文件信息的结构变量，然后按结构变量提供的信息找到该文件， 实施对文件的操作。习惯上也笼统地把fp称为指向一个文件的指针。文件的打开与关闭文件在进行读写操作之前要先打开，使用完毕要关闭。 所谓打开文件，实际上是建立文件的各种有关信息， 并使文件指针指向该文件，以便进行其它操作。关闭文件则断开指针与文件之间的联系，也就禁止再对该文件进行操作。

　　在Ｃ语言中，文件操作都是由库函数来完成的。 在本章内将介绍主要的文件操作函数。

文件打开函数ｆｏｐｅｎ

　 　fopen函数用来打开一个文件，其调用的一般形式为： 文件指针名=fopen(文件名，使用文件方式) 其中，“文件指针名”必须是被说明为FILE 类型的指针变量，“文件名”是被打开文件的文件名。 “使用文件方式”是指文件的类型和操作要求。“文件名”是字符串常量或字符串数组。例如：
FILE *fp；
fp=("file a","r");
其意义是在当前目录下打开文件file a， 只允许进行“读”操作，并使fp指向该文件。

FILE *fphzk
fphzk=("c:hzk16',"rb")
其意义是打开C驱动器磁盘的根目录下的文件hzk16， 这是一个二进制文件，只允许按二进制方式进行读操作。两个反斜线“ ”中的第一个表示转义字符，第二个表示根目录。使用文件的方式共有12种，下面给出了它们的符号和意义。
文件使用方式 　　　　　　　意 义
“rt”　　　　　　只读打开一个文本文件，只允许读数据
“wt”　　　　　　只写打开或建立一个文本文件，只允许写数据
“at”　　　　　　追加打开一个文本文件，并在文件末尾写数据
“rb”　　　　　　只读打开一个二进制文件，只允许读数据
“wb”　　　　 　 只写打开或建立一个二进制文件，只允许写数据
“ab” 　　　　 　追加打开一个二进制文件，并在文件末尾写数据
“rt+”　　　　　 读写打开一个文本文件，允许读和写
“wt+”　　　　　 读写打开或建立一个文本文件，允许读写
“at+”　　　　　 读写打开一个文本文件，允许读，或在文件末追加数 据
“rb+”　　　　　 读写打开一个二进制文件，允许读和写
“wb+”　　　　　 读写打开或建立一个二进制文件，允许读和写
“ab+” 　　　　　读写打开一个二进制文件，允许读，或在文件末追加数据

对于文件使用方式有以下几点说明：
1. 文件使用方式由r,w,a,t,b，+六个字符拼成，各字符的含义是：
r(read): 读
w(write): 写
a(append): 追加
t(text): 文本文件，可省略不写
b(banary): 二进制文件
+: 读和写

2. 凡用“r”打开一个文件时，该文件必须已经存在， 且只能从该文件读出。

3. 用“w”打开的文件只能向该文件写入。 若打开的文件不存在，则以指定的文件名建立该文件，若打开的文件已经存在，则将该文件删去，重建一个新文件。

4. 若要向一个已存在的文件追加新的信息，只能用“a ”方式打开文件。但此时该文件必须是存在的，否则将会出错。

5. 在打开一个文件时，如果出错，fopen将返回一个空指针值NULL。在程序中可以用这一信息来判别是否完成打开文件的工作，并作相应的处理。因此常用以下程序段打开文件：
if((fp=fopen("c:hzk16","rb")==NULL)
{
printf("nerror on open c:hzk16 file!");
getch();
exit(1);
}
　 　这段程序的意义是，如果返回的指针为空，表示不能打开C盘根目录下的hzk16文件，则给出提示信息“error on open c: hzk16file!”，下一行getch()的功能是从键盘输入一个字符，但不在屏幕上显示。在这里，该行的作用是等待， 只有当用户从键盘敲任一键时，程序才继续执行， 因此用户可利用这个等待时间阅读出错提示。敲键后执行exit(1)退出程序。

6. 把一个文本文件读入内存时，要将ASCII码转换成二进制码， 而把文件以文本方式写入磁盘时，也要把二进制码转换成ASCII码，因此文本文件的读写要花费较多的转换时间。对二进制文件的读写不存在这种转换。

7. 标准输入文件(键盘)，标准输出文件(显示器 )，标准出错输出(出错信息)是由系统打开的，可直接使用。文件关闭函数ｆｃｌｏｓｅ文件一旦使用完毕，应用关闭文件函数把文件关闭， 以避免文件的数据丢失等错误。

fclose函数

调用的一般形式是： fclose(文件指针)； 例如：
fclose(fp); 正常完成关闭文件操作时，fclose函数返回值为0。如返回非零值则表示有错误发生。文件的读写对文件的读和写是最常用的文件操作。

在Ｃ语言中提供了多种文件读写的函数：
·字符读写函数 ：fgetc和fputc
·字符串读写函数：fgets和fputs
·数据块读写函数：freed和fwrite
·格式化读写函数：fscanf和fprinf

　　下面分别予以介绍。使用以上函数都要求包含头文件stdio.h。字符读写函数ｆｇｅｔｃ和ｆｐｕｔｃ字符读写函数是以字符(字节)为单位的读写函数。 每次可从文件读出或向文件写入一个字符。

一、读字符函数fgetc

　　fgetc函数的功能是从指定的文件中读一个字符，函数调用的形式为： 字符变量=fgetc(文件指针)； 例如：ch=fgetc(fp);其意义是从打开的文件fp中读取一个字符并送入ch中。

　　对于fgetc函数的使用有以下几点说明：
1. 在fgetc函数调用中，读取的文件必须是以读或读写方式打开的。

2. 读取字符的结果也可以不向字符变量赋值，例如：fgetc(fp);但是读出的字符不能保存。

3. 在文件内部有一个位置指针。用来指向文件的当前读写字节。在文件打开时，该指针总是指向文件的第一个字节。使用fgetc 函数后， 该位置指针将向后移动一个字节。 因此可连续多次使用fgetc函数，读取多个字符。 应注意文件指针和文件内部的位置指针不是一回事。文件指针是指向整个文件的，须在程序中定义说明，只要不重新赋值，文件指针的值是不变的。文件内部的位置 指针用以指示文件内部的当前读写位置，每读写一次，该指针均向后移动，它不需在程序中定义说明，而是由系统自动设置的。

[例10.1]读入文件e10-1.c，在屏幕上输出。
#include
main()
{
FILE *fp;
char ch;
if((fp=fopen("e10_1.c","rt"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
ch=fgetc(fp);
while (ch!=EOF)
{
putchar(ch);
ch=fgetc(fp);
}
fclose(fp);
}
　 　本例程序的功能是从文件中逐个读取字符，在屏幕上显示。 程序定义了文件指针fp,以读文本文件方式打开文件“e10_1.c”， 并使fp指向该文件。如打开文件出错， 给出提示并退出程序。程序第12行先读出一个字符，然后进入循环， 只要读出的字符不是文件结束标志(每个文件末有一结束标志EOF)就把该字符显示在屏幕上，再读入下一字符。每读一次，文件内部的位置指针向后移动一个字 符，文件结束时，该指针指向EOF。执行本程序将显示整个文件。

二、写字符函数fputc

　　fputc函数的功能是把一个字符写入指定的文件中，函数调用的 形式为： fputc(字符量，文件指针)； 其中，待写入的字符量可以是字符常量或变量，例如：fputc('a',fp);其意义是把字符a写入fp所指向的文件中。

　　对于fputc函数的使用也要说明几点：
1. 被写入的文件可以用、写、读写，追加方式打开，用写或读写方式打开一个已存在的文件时将清除原有的文件内容，写入字符从文件首开始。如需保留原有文件内容，希望写入的字符以文件末开始存放，必须以追加方式打开文件。被写入的文件若不存在，则创建该文件。

2. 每写入一个字符，文件内部位置指针向后移动一个字节。

3. fputc函数有一个返回值，如写入成功则返回写入的字符， 否则返回一个EOF。可用此来判断写入是否成功。

[例10.2]从键盘输入一行字符，写入一个文件， 再把该文件内容读出显示在屏幕上。
#include
main()
{
FILE *fp;
char ch;
if((fp=fopen("string","wt+"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
printf("input a string:n");
ch=getchar();
while (ch!='n')
{
fputc(ch,fp);
ch=getchar();
}
rewind(fp);
ch=fgetc(fp);
while(ch!=EOF)
{
putchar(ch);
ch=fgetc(fp);
}
printf("n");
fclose(fp);
}
　 　程序中第6行以读写文本文件方式打开文件string。程序第13行从键盘读入一个字符后进入循环，当读入字符不为回车符时， 则把该字符写入文件之中，然后继续从键盘读入下一字符。 每输入一个字符，文件内部位置指针向后移动一个字节。写入完毕， 该指针已指向文件末。如要把文件从头读出，须把指针移向文件头， 程序第19行rewind函数用于把fp所指文件的内部位置指针移到文件头。 第20至25行用于读出文件中的一行内容。

[例10.3]把命令行参数中的前一个文件名标识的文件， 复制到后一个文件名标识的文件中， 如命令行中只有一个文件名则把该文件写到标准输出文件(显示器)中。

#include
main(int argc,char *argv[])
{
FILE *fp1,*fp2;
char ch;
if(argc==1)
{
printf("have not enter file name strike any key exit");
getch();
exit(0);
}
if((fp1=fopen(argv[1],"rt"))==NULL)
{
printf("Cannot open %sn",argv[1]);
getch();
exit(1);
}
if(argc==2) fp2=stdout;
else if((fp2=fopen(argv[2],"wt+"))==NULL)
{
printf("Cannot open %sn",argv[1]);
getch();
exit(1);
}
while((ch=fgetc(fp1))!=EOF)
fputc(ch,fp2);
fclose(fp1);
fclose(fp2);
}
　 　本程序为带参的main函数。程序中定义了两个文件指针 fp1 和fp2，分别指向命令行参数中给出的文件。如命令行参数中没有给出文件名，则给出提示信息。程序第18行表示如果只给出一个文件名，则使fp2指向标准 输出文件(即显示器)。程序第25行至28行用循环语句逐个读出文件1中的字符再送到文件2中。再次运行时，给出了一个文件名(由例10.2所建立的文 件)， 故输出给标准输出文件stdout，即在显示器上显示文件内容。第三次运行，给出了二个文件名，因此把string中的内容读出，写入到OK之中。可用 DOS命令type显示OK的内容：字符串读写函数ｆｇｅｔｓ和ｆｐｕｔｓ

一、读字符串函数fgets函数的功能是从指定的文件中读一个字 符串到字符数组中，函数调用的形式为： fgets(字符数组名，n，文件指针)； 其中的n是一个正整数。表示从文件中读出的字符串不超过 n-1个字符。在读入的最后一个字符后加上串结束标志''。例如：fgets(str,n,fp);的意义是从fp所指的文件中读出n-1个字符送入字符 数组str中。
[例10.4]从e10_1.c文件中读入一个含10个字符的字符串。
#include
main()
{
FILE *fp;
char str[11];
if((fp=fopen("e10_1.c","rt"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
fgets(str,11,fp);
printf("%s",str);
fclose(fp);
}
　　本例定义了一个字符数组str共11个字节，在以读文本文件方式打开文件e101.c后，从中读出10个字符送入str数组，在数组最后一个单元内将加上''，然后在屏幕上显示输出str数组。输出的十个字符正是例10.1程序的前十个字符。

　　对fgets函数有两点说明：
1. 在读出n-1个字符之前，如遇到了换行符或EOF，则读出结束。
2. fgets函数也有返回值，其返回值是字符数组的首地址。

二、写字符串函数fputs

fputs函数的功能是向指定的文件写入一个字符串，其调用形式为： fputs(字符串，文件指针) 其中字符串可以是字符串常量，也可以是字符数组名， 或指针 变量，例如：
fputs(“abcd“，fp)；
其意义是把字符串“abcd”写入fp所指的文件之中。[例10.5]在例10.2中建立的文件string中追加一个字符串。
#include
main()
{
FILE *fp;
char ch,st[20];
if((fp=fopen("string","at+"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
printf("input a string:n");
scanf("%s",st);
fputs(st,fp);
rewind(fp);
ch=fgetc(fp);
while(ch!=EOF)
{
putchar(ch);
ch=fgetc(fp);
}
printf("n");
fclose(fp);
}
　 　本例要求在string文件末加写字符串，因此，在程序第6行以追加读写文本文件的方式打开文件string 。 然后输入字符串， 并用fputs函数把该串写入文件string。在程序15行用rewind函数把文件内部位置指针移到文件首。 再进入循环逐个显示当前文件中的全部内容。

数据块读写函数ｆｒｅａｄ和ｆｗｒｉｔｅ

　　Ｃ语言还提供了用于整块数据的读写函 数。 可用来读写一组数据，如一个数组元素，一个结构变量的值等。读数据块函数调用的一般形式为： fread(buffer,size,count,fp); 写数据块函数调用的一般形式为： fwrite(buffer,size,count,fp); 其中buffer是一个指针，在fread函数中，它表示存放输入数据的首地址。在fwrite函数中，它表示存放输出数据的首地址。 size 表示数据块的字节数。count 表示要读写的数据块块数。fp 表示文件指针。
例如：
fread(fa,4,5,fp); 其意义是从fp所指的文件中，每次读4个字节(一个实数)送入实数组fa中，连续读5次，即读5个实数到fa中。
[例10.6]从键盘输入两个学生数据，写入一个文件中， 再读出这两个学生的数据显示在屏幕上。
#include
struct stu
{
char name[10];
int num;
int age;
char addr[15];
}boya[2],boyb[2],*pp,*qq;
main()
{
FILE *fp;
char ch;
int i;
pp=boya;
qq=boyb;
if((fp=fopen("stu_list","wb+"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
printf("ninput datan");
for(i=0;i<2;i++,pp++)
scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr);
pp=boya;
fwrite(pp,sizeof(struct stu),2,fp);
rewind(fp);
fread(qq,sizeof(struct stu),2,fp);
printf("nnnametnumber age addrn");
for(i=0;i<2;i++,qq++)
printf("%st%5d%7d%sn",qq->name,qq->num,qq->age,qq->addr);
fclose(fp);
}
　 　本例程序定义了一个结构stu,说明了两个结构数组boya和 boyb以及两个结构指针变量pp和qq。pp指向boya,qq指向boyb。程序第16行以读写方式打开二进制文件“stu_list”，输入二个学 生数据之后，写入该文件中， 然后把文件内部位置指针移到文件首，读出两块学生数据后，在屏幕上显示。

格式化读写函数ｆｓｃａｎｆ和ｆｐｒｉｎｔｆ

fscanf 函数，fprintf函数与前面使用的scanf和printf 函数的功能相似，都是格式化读写函数。 两者的区别在于 fscanf 函数和fprintf函数的读写对象不是键盘和显示器，而是磁盘文件。这两个函数的调用格式为： fscanf(文件指针，格式字符串，输入表列)； fprintf(文件指针，格式字符串，输出表列)； 例如：
fscanf(fp,"%d%s",&i,s);
fprintf(fp,"%d%c",j,ch);
用fscanf和fprintf函数也可以完成例10.6的问题。修改后的程序如例10.7所示。
[例10.7]
#include
struct stu
{
char name[10];
int num;
int age;
char addr[15];
}boya[2],boyb[2],*pp,*qq;
main()
{
FILE *fp;
char ch;
int i;
pp=boya;
qq=boyb;
if((fp=fopen("stu_list","wb+"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
printf("ninput datan");
for(i=0;i<2;i++,pp++)
scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr);
pp=boya;
for(i=0;i<2;i++,pp++)
fprintf(fp,"%s %d %d %sn",pp->name,pp->num,pp->age,pp->
addr);
rewind(fp);
for(i=0;i<2;i++,qq++)
fscanf(fp,"%s %d %d %sn",qq->name,&qq->num,&qq->age,qq->addr);
printf("nnnametnumber age addrn");
qq=boyb;
for(i=0;i<2;i++,qq++)
printf("%st%5d %7d %sn",qq->name,qq->num, qq->age,
qq->addr);
fclose(fp);
}
　　与例10.6相比，本程序中fscanf和fprintf函数每次只能读写一个结构数组元素，因此采用了循环语句来读写全部数组元素。 还要注意指针变量pp,qq由于循环改变了它们的值，因此在程序的25和32行分别对它们重新赋予了数组的首地址。

文件的随机读写

　 　前面介绍的对文件的读写方式都是顺序读写， 即读写文件只能从头开始，顺序读写各个数据。 但在实际问题中常要求只读写文件中某一指定的部分。 为了解决这个问题可移动文件内部的位置指针到需要读写的位置，再进行读写，这种读写称为随机读写。 实现随机读写的关键是要按要求移动位置指针，这称为文件的定位。文件定位移动文件内部位置指针的函数主要有两个， 即 rewind 函数和fseek函数。

　　rewind函数前面已多次使用过，其调用形式为： rewind(文件指针)； 它的功能是把文件内部的位置指针移到文件首。 下面主要介绍
fseek函数。

　 　fseek函数用来移动文件内部位置指针，其调用形式为： fseek(文件指针，位移量，起始点)； 其中：“文件指针”指向被移动的文件。 “位移量”表示移动的字节数，要求位移量是long型数据，以便在文件长度大于64KB 时不会出错。当用常量表示位移量时，要求加后缀“L”。“起始点”表示从何处开始计算位移量，规定的起始点有三种：文件首，当前位置和文件尾。

其表示方法如表10.2。
起始点 　　　表示符号 　　　数字表示
——————————————————————————
文件首 　　　SEEK—SET　　　　0
当前位置 　　SEEK—CUR　　　　1
文件末尾 　　SEEK—END 　　　 2
例如：
fseek (fp,100L,0);其意义是把位置指针移到离文件首100个字节处。还要说明的是fseek函数一般用于二进制文件。在文本文件中由于要进行转换， 故往往计算的位置会出现错误。文件的随机读写在移动位置指针之后， 即可用前面介绍的任一种读写函数进行读写。由于一般是读写一个数据据块，因此常用fread和fwrite函数。下面用例题来说明文件的随机读写。

[例10.8]在学生文件stu list中读出第二个学生的数据。
#include
struct stu
{
char name[10];
int num;
int age;
char addr[15];
}boy,*qq;
main()
{
FILE *fp;
char ch;
int i=1;
qq=&boy;
if((fp=fopen("stu_list","rb"))==NULL)
{
printf("Cannot open file strike any key exit!");
getch();
exit(1);
}
rewind(fp);
fseek(fp,i*sizeof(struct stu),0);
fread(qq,sizeof(struct stu),1,fp);
printf("nnnametnumber age addrn");
printf("%st%5d %7d %sn",qq->name,qq->num,qq->age,
qq->addr);
}
　 　文件stu_list已由例10.6的程序建立，本程序用随机读出的方法读出第二个学生的数据。程序中定义boy为stu类型变量，qq为指向boy的 指针。以读二进制文件方式打开文件，程序第22行移动文件位置指针。其中的i值为1，表示从文件头开始，移动一个stu类型的长度， 然后再读出的数据即为第二个学生的数据。

文件检测函数

Ｃ语言中常用的文件检测函数有以下几个。
一、文件结束检测函数feof函数调用格式： feof(文件指针)；
功能：判断文件是否处于文件结束位置，如文件结束，则返回值为1，否则为0。

二、读写文件出错检测函数ferror函数调用格式： ferror(文件指针)；
功能：检查文件在用各种输入输出函数进行读写时是否出错。 如ferror返回值为0表示未出错，否则表示有错。

三、文件出错标志和文件结束标志置0函数clearerr函数调用格式： clearerr(文件指针);
功能：本函数用于清除出错标志和文件结束标志，使它们为0值。

Ｃ库文件

Ｃ 系统提供了丰富的系统文件，称为库文件，C的库文件分为两类，一类是扩展名为".h"的文件，称为头文件， 在前面的包含命令中我们已多次使用过。在".h"文件中包含了常量定义、 类型定义、宏定义、函数原型以及各种编译选择设置等信息。另一类是函数库，包括了各种函数的目标代码，供用户在程序中调用。 通常在程序中调用一个库函数时，要在调用之前包含该函数原型所在的".h" 文件。
在附录中给出了全部库函数。
ALLOC.H 　　　说明内存管理函数(分配、释放等)。
ASSERT.H 　 　定义 assert调试宏。
BIOS.H 　　 　说明调用IBM—PC ROM BIOS子程序的各个函数。
CONIO.H 　　　说明调用DOS控制台I/O子程序的各个函数。
CTYPE.H 　　　包含有关字符分类及转换的名类信息(如 isalpha和toascii等)。
DIR.H 　　　　包含有关目录和路径的结构、宏定义和函数。
DOS.H 　　　　定义和说明MSDOS和8086调用的一些常量和函数。
ERRON.H 　　　定义错误代码的助记符。
FCNTL.H 　　　定义在与open库子程序连接时的符号常量。
FLOAT.H 　　　包含有关浮点运算的一些参数和函数。
GRAPHICS.H 　 说明有关图形功能的各个函数，图形错误代码的常量定义，正对不同驱动程序的各种颜色值，及函数用到的一些特殊结构。
IO.H 　　　　 包含低级I/O子程序的结构和说明。
LIMIT.H 　　　包含各环境参数、编译时间限制、数的范围等信息。
MATH.H 　　　 说明数学运算函数，还定了 HUGE VAL 宏， 说明了matherr和matherr子程序用到的特殊结构。
MEM.H 　　　　说明一些内存操作函数(其中大多数也在STRING.H 中说明)。
PROCESS.H 　　说明进程管理的各个函数，spawn…和EXEC …函数的结构说明。
SETJMP.H 　　 定义longjmp和setjmp函数用到的jmp buf类型， 说明这两个函数。
SHARE.H 　　　定义文件共享函数的参数。
SIGNAL.H 　　 定义SIG[ZZ(Z] [ZZ)]IGN和SIG[ZZ(Z] [ZZ)]DFL常量，说明rajse和signal两个函数。
STDARG.H 　　 定义读函数参数表的宏。(如vprintf,vscarf函数)。
STDDEF.H 　　 定义一些公共数据类型和宏。
STDIO.H 　　　定义Kernighan和Ritchie在Unix System V 中定义的标准和扩展的类型和宏。还定义标准I/O 预定义流：stdin,stdout和stderr，说明 I/O流子程序。
STDLIB.H 　　 说明一些常用的子程序：转换子程序、搜索/ 排序子程序等。
STRING.H 　　 说明一些串操作和内存操作函数。
SYSSTAT.H 　 定义在打开和创建文件时用到的一些符号常量。
SYSTYPES.H 　说明ftime函数和timeb结构。
SYSTIME.H 　 定义时间的类型time[ZZ(Z] [ZZ)]t。
TIME.H 　　　 定义时间转换子程序asctime、localtime和gmtime的结构，ctime、 difftime、 gmtime、 localtime和stime用到的类型，并提供这些函数的原型。
VALUE.H 　　　定义一些重要常量， 包括依赖于机器硬件的和为与Unix System V相兼容而说明的一些常量，包括浮点和双精度值的范围。
补充：在Unix系统的文本文件中，是用换行符(ASCII 10)作为行结束标记。在Macintosh系统中，是用回车符(ASCII 13)作为行结束标记。而Windows系统则是沿用了DOS系统的标准，换行符和回车符都用来作为行结束标记。

信威笔试

综合能力测试：
3、172，84，40，18 ？
4、8 5 2
4 5 0
+C C C +E E E
A-I分别表示0-9的数字，问A的值
6-9 图形题
2、男医生多于男护士
4、至少有一个女医生
问“我”的性别和职位
11、四个人坐在方桌旁，两个女士A和B,两个男士C和D，四个人分别是游泳，滑冰，体操和
网球运动员
1、游泳在A左边
2、体操在C对面
3、B和D相邻
4、一位女生在滑冰的左边
问谁是网球运动员
12、领导从博物馆难走一块明朝城墙的砖，如何要回来
 

硬件笔试题

  揭露华为、大唐等企业硬件笔试题 [专题文章]

汉王笔试 　　
下面是一些基本的数字电路知识问题，请简要回答之。
　　
a) 什么是Setup 和Holdup时间？
b) 什么是竞争与冒险现象？怎样判断？如何消除？
c) 请画出用D触发器实现2倍分频的逻辑电路？
d) 什么是"线与"逻辑，要实现它，在硬件特性上有什么具体要求？
e) 什么是同步逻辑和异步逻辑？
f) 请画出微机接口电路中，典型的输入设备与微机接口逻辑示意图（数据接口、控制接口、所存器/缓冲器）。
g) 你知道那些常用逻辑电平？TTL与COMS电平可以直接互连吗？
　　
2、 可编程逻辑器件在现代电子设计中越来越重要，请问：
a) 你所知道的可编程逻辑器件有哪些？
b) 试用VHDL或VERILOG、ABLE描述8位D触发器逻辑。
　　
3、 设想你将设计完成一个电子电路方案。请简述用EDA软件（如PROTEL）进行设计（包括原理图和PCB图）到调试出样机的整个过程。在各环节应注意哪些问题？
　　
　　
飞利浦－大唐笔试归来
　　
1，用逻辑们和cmos电路实现ab cd
2. 用一个二选一mux和一个inv实现异或
3. 给了reg的setup,hold时间，求中间组合逻辑的delay范围。 Setup/hold time 是测试芯片对输入信号和时钟信号之间的时间要求。建立时间是指触发器的时钟信号上升沿到来以前，数据稳定不变的时间。输入信号应提前时钟上升沿（如上升沿 有效）T时间到达芯片，这个T就是建立时间-Setup time.如不满足setup time,这个数据就不能被这一时钟打入触发器，只有在下一个时钟上升沿，数据才能被打入触发器。 保持时间是指触发器的时钟信号上升沿到来以后，数据稳定不变的时间。时hold time不够，数据同样不能被打入触发器。
4. 如何解决亚稳态
5. 用verilog/vhdl写一个fifo控制器
6. 用verilog/vddl检测stream中的特定字符串
　　　　
信威dsp软件面试题
　　
1)DSP和通用处理器在结构上有什么不同，请简要画出你熟悉的一种DSP结构图
　　
2)说说定点DSP和浮点DSP的定义（或者说出他们的区别）
　　
3)说说你对循环寻址和位反序寻址的理解
　　
4)请写出【－8，7】的二进制补码，和二进制偏置码。 用Q15表示出0.5和－0.5
　　
扬智电子笔试
　　
第一题：用mos管搭出一个二输入与非门。
第二题：集成电路前段设计流程，写出相关的工具。
第三题：名词IRQ,BIOS,USB,VHDL,SDR
第四题：unix 命令cp -r, rm,uname
第五题：用波形表示D触发器的功能
第六题：写异步D触发器的verilog module
第七题：What is PC Chipset?
第八题：用传输门和倒向器搭一个边沿触发器
第九题：画状态机，接受1，2，5分钱的卖报机，每份报纸5分钱。
　　
华为面题 (硬件)
全都是几本模电数电信号单片机题目
1.用与非门等设计全加法器
2.给出两个门电路让你分析异同
3.名词:sram,ssram,sdram
4.信号与系统:在时域与频域关系
5.信号与系统:和4题差不多
6.晶体振荡器,好像是给出振荡频率让你求周期(应该是单片机的,12分之一周期....)
7.串行通信与同步通信异同,特点,比较
8.RS232c高电平脉冲对应的TTL逻辑是?(负逻辑?)
9.延时问题,判错
10.史密斯特电路,求回差电压
11.VCO是什么,什么参数(压控振荡器?)
12. 用D触发器做个二分颦的电路.又问什么是状态图
13. 什么耐奎斯特定律,怎么由模拟信号转为数字信号
14. 用D触发器做个4进制的计数
15.那种排序方法最快?
　　
一、 研发（软件）
用C语言写一个递归算法求N！；
给一个C的函数，关于字符串和数组，找出错误；
防火墙是怎么实现的？
你对哪方面编程熟悉？
　　
新太硬件面题

（1）d触发器和d锁存器的区别
（2）有源滤波器和无源滤波器的原理及区别
（3）sram，falsh memory，及dram的区别？
（4）iir，fir滤波器的异同
（5）冒泡排序的原理
（6）操作系统的功能
（7）学过的计算机语言及开发的系统
（8）拉氏变换和傅立叶变换的表达式及联系。
 
 

C语言变量和数据存储

C语言的强大功能之一是可以灵活地定义数据的存储方式。C语言从两个方面控制变量的性质：作用域(scope)和生存期(lifetime)。作用域是指可以存取变量的代码范围，生存期是指可以存取变量的时间范围。
作用域有三种：
1. extern(外部的) 这是在函数外部定义的变量的缺省存储方式。extern变量的作用域是整个程序。
2．static(静态的) 在函数外部说明为static的变量的作用域为从定义点到该文件尾部；在函数内部说明为static的变量的作用域为从定义点到该局部程序块尾部。
3．auto(自动的) 这是在函数内部说明的变量的缺省存储方式。auto变量的作用域为从定义点到该局部程序块尾部。
变 量的生存期也有三种，但它们不象作用域那样有预定义的关键字名称。第一种是extern和static变量的生存期，它从main()函数被调用之前开 始，到程序退出时为止。第二种是函数参数和auto变量的生存期，它从函数调用时开始，到函数返回时为止。第三种是动态分配的数据的生存期，它从程序调用 malloc()或calloc()为数据分配存储空间时开始，到程序调用free()或程序退出时为止。

变量可以存储在内存中的不同 地方，这依赖于它们的生存期。在函数外部定义的变量(全局变量或静态外部变量)和在函数内部定义的static变量，其生存期就是程序运行的全过程，这些 变量被存储在数据段(datasegment)中。数据段是在内存中为这些变量留出的一段大小固定的空间，它分为两部分，一部分用来存放初始化变量，另一 部分用来存放未初始化变量。
在函数内部定义的auto变量(没有用关键字static定义的变量)的生存期从程序开始执行其所在的程序块代码时开 始，到程序离开该程序块时为止。作为函数参数的变量只在调用该函数期间存在。这些变量被存储在栈(stack)中。栈是内存中的一段空间，开始很小，以后 逐渐自动增大，直到达到某个预定义的界限。在象DOS这样的没有虚拟内存(virtual memory)的系统中，这个界限由系统决定，并且通常非常大，因此程序员不必担心用尽栈空间。关于虚拟内存 的讨论，请参见2．3。
第三种 (也是最后一种)内存空间实际上并不存储变量，但是可以用来存储变量所指向的数据。如果把调用malloc()函数的结果赋给一个指针变量，那么这个指针 变量将包含一块动态分配的内存的地址，这块内存位于一段名为“堆(heap)”的内存空间中。堆开始时也很小，但当程序员调用malloc()或 calloc()等内存分配函数时它就会增大。堆可以和数据段或栈共用一个内存段(memorysegment)，也可以有它自己的内存段，这完全取决于 编译选项和操作系统。
与栈相似，堆也有一个增长界限，并且决定这个界限的规则与栈相同。

请参见：
1．1 什么是局部程序块(10calblock)?
2．2 变量必须初始化吗?
2．3 什么是页抖动(pagethrashing)?
7．20 什么是栈(stack)?
7．21 什么是堆(heap)7 ．

不。 使用变量之前应该给变量一个值，一个好的编译程序将帮助你发现那些还没有被给定一个值就被使用的变量。不过，变量不一定需要初始化。在函数外部定义的变量 或者在函数内部用static关键字定义的变量(被定义在数据段中的那些变量，见2．1)在没有明确地被程序初始化之前都已被系统初始化为0了。在函数内 部或程序块内部定义的不带static关键字的变量都是自动变量，如果你没有明确地初始化这些变量，它们就会具有未定义值。如果你没有初始化一个自动变 量，在使用它之前你就必须保证先给它赋值。
调用malloc()函数从堆中分配到的空间也包含未定义的数据，因此在使用它之前必须先进行初始化，但调用calloc()函数分配到的空间在分配时就已经被初始化为0了。

请参见：
1．1 什么是局部程序块(10calblock)?
7．20 什么是栈(stack)?
7．21 什么是堆(heap)?

有些操作系统(如UNIX和增强模式下的Windows)使用虚拟内存，这是一种使机器的作业地址空间大于实际内存的技术，它是通过用磁盘空间模拟RAM(random—access memory)来实现的。
在80386 和更高级的Intel CPU芯片中，在现有的大多数其它微处理器(如Motorola 68030，sparc和Power PC)中，都有一个被称为内存管理单元(Memory Management Unit，缩写为MMU)的器件。MMU把内存看作是由一系列“页(page)”组成的来处理。一页内存是指一个具有一定大小的连续的内存块，通常为 4096或8192字节。操作系统为每个正在运行的程序建立并维护一张被称为进程内存映射(Process Memory Map，缩与为PMM)的表，表中记录了程序可以存取的所有内存页以及它们的实际位置。
每当程序存取一块内存时，它会把相应的地址(虚拟地址， virtualaddress)传送给MMU，MMU会在PMM中查找这块内存的实际位置(物理地址，physical address)，物理地址可以是由操作系统指定的在内存中或磁盘上的任何位置。如果程序要存取的位置在磁盘上，就必须把包含该地址的页从磁盘上读到内存 中，并且必须更新PMM以反映这个变化(这被称为pagefault，即页错)。
希望你继续读下去，因为下面就要介绍其中的难点了。存取磁盘比存 取RAM要慢得多，所以操作系统会试图在RAM中保持尽量多的虚拟内存。如果你在运行一个非常大的程序(或者同时运行几个小程序)，那么可能没有足够的 RAM来承担程序要使用的全部内存，因此必须把一些页从RAM中移到磁盘上(这被为pagingout，即页出)。
操作系统会试图去判断哪些 页可能暂时不会被使用(通常基于过去使用内存的情况)，如果它判断错了，或者程序正在很多地方存取很多内存，那么为了读入已调出的页，就会产生大量页错动 作。因为RAM已被全部使用，所以为了调入要存取的一页，必须调出另一页，而这将导致更多的页错动作，因为此时不同的一页已被移到磁盘上。在短时间内出现 大量页错动作的情形被称为页抖动，它将大大降低系统的执行效率。
频繁存取内存中大量散布的位置的程序更容易在系统中造成页抖动。如果同时运行许多 小程序，而实际上已经不再使用这些程序，也很容易造成页抖动。为了减少页抖动，你应该减少同时运行的程序的数目。对于大的程序，你应该改变它的工作方式， 以尽量使操作系统能准确地判断出哪些页不再需要。为此，你可以使用高速缓冲存储技术，或者改变用于大型数据结构的查找算法，或者使用效率更高的 malloc()函数。当然，你也可以考虑增加系统的RAM，以减少页出动作。

请参见：
7．17 怎样说明一个大于640KB的数组?
7．21 什么是堆(heap)?
18．14 怎样才能使DOS程序获得超过64KB的可用内存?
21．31 Windows是怎样组织内存的?

如果希望一个变量在被初始化后其值不会被修改，程序员就会通过cons,修饰符和编译程序达成默契。编译程序会努力去保证这种默契——它将禁止程序中出现对说明为const的变量进行修改的代码。
const 指针的准确提法应该是指向const数据的指针，即它所指向的数据不能被修改。只要在指针说明的开头加入const修饰符，就可说明一个cosnt指针。 尽管const指针所指向的数据不能被修改，但cosnt指针本身是可以修改的。下面给出了const指针的一些合法和非法的用法例子：
const char *str="hello";
char c=*str; /*legal*/
str++; /*legal*/
*str='a'; /* illegal */
str[1]＝'b'; /*illegal*/
前两条语句是合法的，因为它们没有修改str所指向的数据；后两条语句是非法的，因为它们要修改str所指向的数据。
在说明函数参数时，常常要使用const指针。例如，一个计算字符串长度的函数不必改变字符串内容，它可以写成这样：
my_strlen(const char *str)
{
int count=0;
while ( * str++)
{
count ++;
}
return count;
}

注意，如果有必要，一个非const指针可以被隐式地转换为const指针，但一个const指针不能被转换成非const指针。这就是说，在调用my_strlen()时，它的参数既可以是一个const指针，也可以是一个非const指针。

请参见：
2．7 一个变量可以同时被说明为const和volatile吗?
2．8 什么时候应该使用const修饰符?
2．14 什么时候不应该使用类型强制转换(type cast)?
2. 18 用const说明常量有什么好处?

 
register修饰符暗示编译程序相应的变量将被频繁使用，如果可能的话，应将其保存在CPU的寄存器中，以加快其存取速度。但是，使用register修饰符有几点限制。
首先，register变量必须是能被CPU寄存器所接受的类型。这通常意味着register变量必须是一个单个的值，并且其长度应小于或等于整型的长度。但是，有些机器的寄存器也能存放浮点数。
其次，因为register变量可能不存放在内存中，所以不能用取址运算符“&”来获取register变量的地址。如果你试图这样做，编译程序就会报告这是一个错误。
register 修饰符的用处有多大还受其它一些规则的影响。因为寄存器的数量是有限的，而且某些寄存器只能接受特定类型的数据(如指针和浮点数)，因此，真正能起作用的 register修饰符的数目和类型都依赖于运行程序的机器，而任何多余的register修饰符都将被编译程序所忽略。
在某些情况下，把变量保存在寄存器中反而会降低运行速度，因为被占用的寄存器不能再用于其它目的，或—者变量被使用的次数不够多，不足以抵消装入和存储变量所带来的额外开销。
那 么，什么时候应该使用register修饰符呢?回答是，对现有的大多数编译程序来说，永远不要使用register修饰符。早期的C编译程序不会把变量 保存在寄存器中，除非你命令它这样做，这时register修饰符是C语言的一种很有价值的补充。然而，随着编译程序设计技术的进步，在决定哪些变量应该 被存到寄存器中时，现在的C编译程序能比程序员作出更好的决定。
实际上，许多C编译程序会忽略register修饰符，因为尽管它完全合法，但它仅仅是暗示而不是命令。
在极罕见的情况下，程序运行速度很慢，而你也知道这是因为有一个变量被存储在内存中，也许你最后会试图在该变量前面加上register修饰符，但是，如果这并没有加快程序的运行速度，你也不要感到奇怪。

请参见：
2．6 什么时候应该使用volatile修饰符?

volatile 修饰符告诉编译程序不要对该变量所参与的操作进行某些优化。在两种特殊的情况下需要使用volatile修饰符：第一种情况涉及到内存映射硬件 (memory-mapped hardware，如图形适配器，这类设备对计算机来说就好象是内存的一部分一样)，第二种情况涉及到共享内存(shared memory，即被两个以上同时运行的程序所使用的内存)。
大多数计算机拥有一系列寄存器，其存取速度比计算机主存更快。好的编译程序能进行一种 被称为“冗余装入和存储的删去”(redundant load and store removal)的优化，即编译程序会·在程序中寻找并删去这样两类代码：一类是可以删去的从内存装入数据的指令，因为相应的数据已经被存放在寄存器中； 另一种是可以删去的将数据存入内存的指令，因为相应的数据在再次被改变之前可以一直保留在寄存器中。
如果一个指针变量指向普通内存以外的位置，如指向一个外围设备的内存映射端口，那么冗余装入和存储的优化对它来说可能是有害的。例如，为了调整某个操作的时间，可能会用到下述函数：

time_t time_addition(volatile const struct timer * t, int a),
{
int n
int x
time_t then
x=O;
then= t->value
for (n=O; n<1O00; n++)
{
x=x+a ;
}
return t->value - then;
}

在上述函数中，变量t->value实际上是一个硬件计数器，其值随时间增加。该函数执行1000次把a值加到x上的操作，然后返回t->value在这1000次加法的执行期间所增加的值。
如 果不使用volatile修饰符，一个聪明的编译程序可能就会认为t->value在该函数执行期间不会改变，因为该函数内没有明确地改变t- >value的语句。这样，编译程序就会认为没有必要再次从内存中读入t->value并将其减去then，因为答案永远是0。因此，编译程 序可能会对该函数进行“优化”，结果使得该函数的返回值永远是0。
如果一个指针变量指向共享内存中的数据，那么冗余装入和存储的优化对它来说可能 也是有害的，共享内存通常用来实现两个程序之间的互相通讯，即让一个程序把数据存到共享的那块内存中，而让另一个程序从这块内存中读数据。如果从共享内存 装入数据或把数据存入共享内存的代码被编译程序优化掉了，程序之间的通讯就会受到影响。

请参见：
2．7 一个变量可以同时被说明为const和volatile吗?
2．14 什么时候不应该使用类型强制转换(typecast)?

  可以。const修饰符的含义是变量的值不能被使用了const修饰符的那段代码修改，但这并不意味着它不能被这段代码以外的其它手段修改。例如，在2． 6的例子中，通过一个volatile const指针t来存取timer结构。函数time_addition()本身并不修改t->value的值，因此t->value被说明 为const。不过，计算机的硬件会修改这个值，因此t->value又被说明为volatile。如果同时用const和volatile来说明 一个变量，那么这两个修饰符随便哪个在先都行，

请参见：
2．6什么时候应该使用volatile修饰符?
2．8什么时候应该使用const修饰符?
2．14什么时候不应该使用类型强制转换(typecast)?

 使用const修饰符有几个原因，第一个原因是这样能使编译程序找出程序中不小心改变变量值的错误。请看下例：

while ( * str=0) / * programmer meant to write * str! =0 * /
{
/ * some code here * /
strq++;
}

其中的“＝”符号是输入错误。如果在说明str时没有使用const修饰符，那么相应的程序能通过编译但不能被正确执行。
第二个原因是效率。如果编译程序知道某个变量不会被修改，那么它可能会对生成的代码进行某些优化。
如 果一个函数参数是一个指针，并且你不希望它所指向的数据被该函数或该函数所调用的函数修改，那么你应该把该参数说明为const指针。如果一个函数参数通 过值(而不是通过指针)被传递给函数，并且你不希望其值被该函数所调用的函数修改，那么你应该把该参数说明为const。然而，在实际编程中，只有在编译 程序通过指针存取这些数据的效率比拷贝这些数据更高时，才把这些参数说明为const。

请参见：
2．7 一个变量可以同时被说明为const和volatile吗?
2．14 什么时候不应该使用类型强制转换(typecast)?
2．18用const说明常量有什么好处?

浮点数是计算机编程中的“魔法(black art)”，原因之一是没有一种理想的方式可以表示一个任意的数字。电子电气工程协会(IEEE)已经制定出浮点数的表示标准，但你不能保证所使用的每台机器都遵循这一标准。
即 使你使用的机器遵循这一标准，还存在更深的问题。从数学意义上讲，两个不同的数字之间有无穷个实数。计算机只能区分至少有一位(bit)不同的两个数字。 如果要表示那些无穷无尽的各不相同的数字，就要使用无穷数目的位。计算机只能用较少的位(通常是32位或64位)来表示一个很大的范围内的数字，因此它只 能近似地表示大多数数字。
由于浮点数是如此难对付，因此比较一个浮点数和某个值是否相等或不等通常是不好的编程习惯。但是，判断一个浮点数是否大于或小于某个值就安全多了。例如，如果你想以较小的步长依次使用一个范围内的数字，你可能会编写这样一个程序：

#include
const float first = O.O;
const float last = 70.0
const float small= O.007
main ( )
{
float f;
for (f=first; f !=last && fprintf("f is now %gn", f);
}

然 而，舍入误差(rounding error)和变量small的表示误差可能导致f永远不等于last(f可能会从稍小于last的一个数增加到一个稍大于last的数)，这样，循环会 跳过last。加入不等式"f一种较安全的方法是用不等式"ffloat f;
for(f=first; f；
你甚至可以预先算出循环次数，然后通过这个整数进行循环计数：
float f；
int count＝(last-first)/small；
for(f=first；count-->0；f+=small)
；

请参见：
2．11 对不同类型的变量进行算术运算会有问题吗?

要判断某种特定类型可以容纳的最大值或最小值，一种简便的方法是使用ANSI标准头文件limits.h中的预定义值。该文件包含一些很有用的常量，它们定义了各种类型所能容纳的值，下表列出了这些常量：
----------------------------------------------------------------
常 量 描 述
----------------------------------------------------------------
CHAR—BIT char的位数(bit)
CHAR—MAX char的十进制整数最大值
CHAR—MIN char的十进制整数最小值
MB—LEN—MAX 多字节字符的最大字节(byte)数
INT—MAX int的十进制最大值
INT—MIN int的十进制最小值
LONG—MAX long的十进制最大值
LONG—MIN long的十进制最小值
SCHAR—MAX signedchar的十进制整数最大值
SCHAR—MIN signedchar的十进制整数最小值
SHRT—MIN short的十进制最小值
SHRT—MAX short的十进制最大值
UCHAR—MAX unsignedchar的十进制整数最大值
UINT—MAX unsignedint的十进制最大值
ULONG—MAX unsignedlongint的十进制最大值
USHRT—MAX unsignedshortint的十进制最大值
-----------------------------------------------------------------
对 于整数类型，在使用2的补码运算的机器(你将使用的机器几乎都属此类)上，一个有符号类型可以容纳的数字范围为-2位数-1到(+2位数-1-1)，一个 无符号类型可以容纳的数字范围为0到(+2位数-1)。例如，一个16位有符号整数可以容纳的数字范围为--215(即-32768)到(+215-1) (即+32767)。

请参见：
10．1用什么方法存储标志(flag)效率最高?
10．2什么是“位屏幕(bitmasking)”?
10．6 16位和32位的数是怎样存储的?

C有三类固有的数据类型：指针类型、整数类型和浮点类型；
指针类型的运算限制最严，只限于以下两种运算：
- 两个指针相减，仅在两个指针指向同一数组中的元素时有效。运算结果与对应于两个指针的数组下标相减的结果相同。
+ 指针和整数类型相加。运算结果为一个指针，该指针与原指针之间相距n个元素，n就是与原指针相加的整数。
浮 点类型包括float，double和longdouble这三种固有类型。整数类型包括char，unsigned char，short，unsigned short，int，unsigned int，long和unsigned long。对这些类型都可进行以下4种算术运算：
+ 加
- 减
* 乘
/ 除
对整数类型不仅可以进行上述4种运算，还可进行以下几种运算：
% 取模或求余
>> 右移
<< 左移
& 按位与
| 按位或
^ 按位异或
! 逻辑非
~ 取反
尽管C允许你使用“混合模式”的表达式(包含不同类型的算术表达式)，但是，在进行运算之前，它会把不同的类型转换成同一类型(前面提到的指针运算除外)。这种自动转换类型的过程被称为“运算符升级(operator promotion)”。

请参见：
2．12什么是运算符升级(operatorpromotion)?

当两个不同类型的运算分量(operand)进行运算时，它们会被转换为能容纳它们的最小的类型，并且运算结果也是这种类型。下表列出了其中的规则，在应用这些规则时，你应该从表的顶端开始往下寻找，直到找到第一条适用的规则。
-------------------------------------------------------------
运算分量1 运算分量2 转换结果
-------------------------------------------------------------
long double 其它任何类型 long double
double 任何更小的类型 double
float 任何更小的类 float
unsigned long 任何整数类 unsigned long
long unsigned>LONG_MAX unsigned long
long 任何更小的类型 long
unsigned 任何有符号类型 unsigned
-------------------------------------------------------------
下面的程序中就有几个运算符升级的例子。变量n被赋值为3/4，因为3和4都是整数，所以先进行整数除法运算，结果为整数0。变量f2被赋值为3/4.0，因为4.0是一个float类型，所以整数3也被转换为float类型，结果为float类型0.75。
#include
main ()
{
float f1 = 3/4;
float f2 = 3/4.0
printf("3/4== %g or %g depending on the type used. n",f1, f2);
}

请参见：
2．11对不同类型的变量进行算术运算会有问题吗?
2．13什么时候应该使用类型强制转换(typecast)?

在 两种情况下需要使用类型强制转换。第一种情况是改变运算分量的类型，从而使运算能正确地进行。下面的程序与2．12中的例子相似，但有不同之处。变量n被 赋值为整数i除以整数j的结果，因为是整数相除，所以结果为0。变量f2也被赋值为i除以j的结果，但本例通过(float)类型强制转换把i转换成一个 float类型，因此执行的是浮点数除法运算(见2．11)，结果为0．75。
#include
main ( )
{
int i = 3;
int j = 4
float f1 =i/j;
float f2= (float) i/j;
printf("3/4== %g or %g depending on the type used. n",f1, f2);
}

第二种情况是在指针类型和void * 类型之间进行强制转换，从而与期望或返回void指针的函数进行正确的交接。例如，下述语句就把函数malloc()的返回值强制转换为一个指向foo结构的指针：
struct foo *p＝(struct foo *)malloc(sizeof(struct foo))；

请参见：
2．6什么时候应该使用volatile修饰符?
2．8什么时候应该使用const修饰符?
2．11对不同类型的变量进行算术运算会有问题吗?
2．12 什么是运算符升级(operator promotion)?
2．14 什么时候不应该使用类型强制转换(typecast)?
7．5 什么是void指针?
7．6 什么时候使用void指针?
7．21 什么是堆(heap)?
7．27 可以对void指针进行算术运算吗?

不应该对用const或volatile说明了的对象进行类型强制转换，否则程序就不能正确运行。
不应该用类型强制转换把指向一种结构类型或数据类型的指针转换成指向另一种结构类型或数据类型的指针。在极少数需要进行这种类型强制转换的情况下，用共用体(union)来存放有关数据能更清楚地表达程序员的意图。

请参见：
2. 6什么时候应该使用volatile修饰符?
2. 8什么时候应该使用const修饰符?

被 多个文件存取的全局变量可以并且应该在一个头文件中说明，并且必须在一个源文件中定义。变量不应该在头文件中定义，因为一个头文件可能被多个源文件包含， 而这将导致变量被多次定义。如果变量的初始化只发生一次，ANSIC标准允许变量有多次外部定义；但是，这样做没有任何好处，因此最好避免这样做，以使程 序有更强的可移植性。
注意：变量的说明和定义是两个不同的概念，在2．16中将讲解两者之间的区别。
仅供一个文件使用的“全局”变量应该被说明为static，而且不应该出现在头文件中。

请参见：
2. 16 说明一个变量和定义一个变量有什么区别?
2. 17 可以在头文件中说明static变量吗?

说明一个变量意味着向编译程序描述变量的类型，但并不为变量分配存储空间。定义一个变量意味着在说明变量的同时还要为变量分配存储空间。在定义一个变量的同时还可以对变量进行初始化。下例说明了一个变量和一个结构，定义了两个变量，其中一个定义带初始化：
extern int decll; / * this is a declaration * /
struct decl2 {
int member;
} ; / * this just declares the type--no variable mentioned * /
int def1 = 8; / * this is a definition * /
int def2; / * this is a definition * /

换句话说，说明一个变量相当于告诉编译程序“在程序的某个位置将用到一个变量，这里给出了它的名称和类型”，定义一个变量则相当于告诉编译程序“具有这个名称和这种类型的变量就在这里”。
一个变量可以被说明许多次，但只能被定义一次。因此，不应该在头文件中定义变量，因为一个头文件可能会被一个程序的许多源文件所包含。

请参见；
2．17可以在头文件中说明static变量吗?

如果说明了一个static变量，就必须在同一个文件中定义该变量(因为存储类型修饰符static和extern是互斥的)。你可以在头文件中定义一个static变量，但这会使包含该头文件的源文件都得到该变量的一份私有拷贝，而这通常不是你想得到的结果。

请参见：
2．16 说明一个变量和定义一个变量有什么区别?

使用关键字const有两个好处；第一，如果编译程序知道一个变量的值不会改变，编译程．序就能对程序进行优化；第二，编译程序会试图保证该变量的值不会因为程序员的疏忽而被改变。
当 然，用#define来定义常量也有同样的好处。用const而不用#define来定义常量的原因是const变量可以是任何类型(如结构，而用 #define定义的常量不能表示结构)。此外，const变量是真正的变量，它有可供使用的地址，并且该地址是唯一的(有些编译程序在每次使用用 #define定义的字符串时都会生成一份新的拷贝，见9．9)。

请参见：
2．7 一个变量可以同时被说明为const和volatile吗?
2．8 什么时候应该使用const修饰符?
2．14 什么时候不应该使用类型强制转换(typecast)?
9．9 字符串和数组有什么不同?