C语言之指针、数组和函数
基本解释

　　1、指针的本质是一个与地址相关的复合类型，它的值是数据存放的位置（地址）；数组的本质则是一系列的变量。

　　2、数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。

　　3、当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

　　问题：指针与数组

　　听说char a[]与char *a是一致的，是不是这样呢？

　　答案与分析：

　　指针和数组存在着一些本质的区别。当然，在某种情况下，比如数组作为函数的参数进行传递时，由于该数组自动退化为同类型的指针，所以在函数内部，作为函数参数传递进来的指针与数组确实具有一定的一致性，但这只是一种比较特殊的情况而已，在本质上，两者是有区别的。请看以下的例子：

char a[] = "Hi, pig!";
char *p = "Hi, pig!";

　　上述两个变量的内存布局分别如下：

　　数组a需要在内存中占用8个字节的空间，这段内存区通过名字a来标志。指针p则需要4个字节的空间来存放地址，这4个字节用名字p来标志。其中存放的地址几乎可以指向任何地方，也可以哪里都不指，即空指针。目前这个p指向某地连续的8个字节，即字符串“Hi, pig!”。

　　另外，例如：对于a[2]和p[2]，二者都返回字符‘i’，但是编译器产生的执行代码却不一样。对于a[2]，执行代码是从a的位置开始，向后移动2两个字节，然后取出其中的字符。对于p[2]，执行代码是从p的位置取出一个地址，在其上加2，然后取出对应内存中的字符。

　　问题：数组指针

　　为什么在有些时候我们需要定义指向数组而不是指向数组元素的指针？如何定义？

　　答案与分析：

　　使用指针，目的是用来保存某个元素的地址，从而来利用指针独有的优点，那么在元素需要是数组的情况下，就理所当然要用到指向数组的指针，比如在高维需要动态生成情况下的多维数组。

　　定义例子如下： int (*pElement)[2]。

　　下面是一个例子：

int array[2][3] = {{1，2，3}，{4，5，6}};
int (*pa)[3]; //定义一个指向数组的指针
pa = &array[0]; // '&'符号能够体现pa的含义，表示是指向数组的指针
printf ("%d", (*pa)[0]）; //将打印array[0][0]，即1
pa++； // 猜一猜，它指向谁？array[1]？对了！
printf ("%d", (*pa)[0]); // 将打印array[1][0]，即4

　　上述这个例子充分说明了数组指针—一种指向整个数组的指针的定义和使用。

　　需要说明的是，按照我们在第四篇讨论过的，指针的步进是参照其所指对象的大小的，因此，pa++将整个向后移动一个数组的尺寸，而不是仅仅向后移动一个数组元素的尺寸。

　　问题：指针数组

　　有如下定义：

struct UT_TEST_STRUCT *pTo[2][MAX_NUM];

　　请分析这个定义的意义，并尝试说明这样的定义可能有哪些好处？

　　答案与分析：

　　前面我们谈了数组指针，现在又提到了指针数组，两者形式很相似，那么，如何区分两者的定义呢？分析如下：

　　数组指针是：指向数组的指针，比如 int (*pA)[5]。

　　指针数组是：指针构成的数组，比如int *pA[5]。

　　至于上述指针数组的好处，大致有如下两个很普遍的原因：

　　a)、各个指针内容可以按需要动态生成，避免了空间浪费。

　　b)、各个指针呈数组形式排列，索引起来非常方便。

　　在实际编程中，选择使用指针数组大多都是想要获得如上两个好处。

　　问题：指向指针的指针

　　在做一个文本处理程序的时候，有这样一个问题：什么样的数据结构适合于按行存储文本？

　　答案与分析：

　　首先，我们来分析文本的特点，文本的主要特征是具有很强的动态性，一行文本的字符个数或多或少不确定，整个文本所拥有的文本行数也是不确定的。这样的特征决定了用固定的二维数组存放文本行必然限制多多，缺乏灵活性。这种场合，使用指向指针的指针有很大的优越性。

　　现实中我们尝试用动态二维数组（本质就是指向指针的指针）来解决此问题：

　　图示是一个指针数组。所谓动态性指横向（对应每行文本的字符个数）和纵向（对应整个文本的行数）两个方向都可以变化。

　　就横向而言，因为指针的灵活性，它可以指向随意大小的字符数组，实现了横向动态性。

　　就竖向而言，可以动态生成及扩展需要的指针数组的大小。

　　下面的代码演示了这种动态数组的用途：

// 用于从文件中读取以 '\0'结尾的字符串的函数
extern char *getline(FILE *pFile);
FILE *pFile;
char **ppText = NULL; // 二维动态数组指针
char *pCurrText = NULL； // 指向当前输入字符串的指针
ULONG ulCurrLines = 0；
ULONG ulAllocedLines = 0；

while （p = getline(pFile))
{
　if (ulCurrLines >= ulAllocedLines)
　{
　　// * 当前竖向空间已经不够了，通过realloc对其进行扩展。
　　ulAllocedLines += 50; // 每次扩展50行。
　　ppText = realloc (ppText, ulAllocedLines * (char *));
　　if (NULL == ppText)
　　{
　　　return; // 内存分配失败，返回
　　}
　}
　ppText[ulCurrLines++] = p; // 横向“扩展”，指向不定长字符串
}

　　问题：指针数组与数组指针与指向指针的指针

　　指针和数组分别有如下的特征：

　　指针：动态分配，初始空间小

　　数组：索引方便，初始空间大

　　下面使用高维数组来说明指针数组、数组指针、指向指针的指针各自的适合场合。

　　 多维静态数组:各维均确定，适用于整体空间需求不大的场合，此结构可方便索引，例a[10][40]。

　　 数组指针：低维确定，高维需要动态生成的场合，例a[x][40]。

　　 指针数组：高维确定，低维需要动态生成的场合，例a[10][y]。

　　 指向指针的指针：高、低维均需要动态生成的场合，例a[x][y]。

　　问题：数组名相关问题

　　假设有一个整数数组a，a和&a的区别是什么？

　　答案与分析：

　　a == &a == &a[0],数组名a不占用存储空间。需要引用数组(非字符串)首地址的地方，我一般使用&a[0]，使用a容易和指针混淆，使用&a容易和非指针变量混淆。

　　区别在于二者的类型。对数组a的直接引用将产生一个指向数组第一个元素的指针，而&a的结果则产生一个指向全部数组的指针。例如：

int a[2] = {1, 2};
int *p = 0;
p = a; /* p指向a[0]所在的地方 */
x = *p; /* x = a[0] = 1*/
p = &a; /* 编译器会提示你错误，*/
/*显示整数指针与整数数组指针不一样 */

　　问题：函数指针与指针函数
　
　　请问：如下定义是什么意思：

int *pF1();
int (*pF2)();

　　答案与分析：

　　首先清楚它们的定义：

　　 指针函数，返回一个指针的函数。

　　 函数指针，指向一个函数的指针。

　　可知：

　　 pF1是一个指针函数，它返回一个指向int型数据的指针。

　　 pF2是一个函数指针，它指向一个参数为空的函数，这个函数返回一个整数。

[此贴子已经被作者于2006-11-30 21:10:07编辑过]

C语言之指针综合谈

指针类型的本质分析

　　1、指针的本质

　　指针的本质：一种复合的数据类型。下面我将以下面几个作为例子进行展开分析：

　　a)、int *p;
　　b)、int **p;
　　c)、int (*parValue)[3];
　　d)、int (*pFun)();

　　分析：

　　所谓的数据类型就是具有某种数据特征的东东，比如数据类型char，它的数据特征就是它所占据的内存为1个字节, 指针也很类似，指针所指向的值也占据着内存中的一块地址，地址的长度与指针的类型有关，比如对于char型指针，这个指针占据的内存就是1个字节，因此指针也是一种数据类型，但我们知道指针本身也占据了一个内存空间地址，地址的长度和机器的字长有关，比如在32位机器中，这个长度就是4个字节，因此指针本身也同样是一种数据类型，因此，我们说，指针其实是一种复合的数据类型，

　　好了，现在我们可以分析上面的几个例子了。

　　假设有如下定义：

int nValue;

　　那么，nValue的类型就是int，也就是把nValue这个具体变量去掉后剩余的部分，因此，上面的4个声明可以类比进行分析：

　　a)、int *

　　*代表变量（指针本身）的值是一个地址，int代表这个地址里面存放的是一个整数，这两个结合起来，int *定义了一个指向整数的指针，类推如下:

　　b)、int **

　　指向一个指向整数的指针的指针。

　　c)、int (*)[3]

　　指向一个拥有三个整数的数组的指针。

　　d)、int (*)()

　　指向一个函数的指针，这个函数参数为空，返回值为整数。

　　分析结束，从上面可以看出，指针包括两个方面，一个是它本身的值，是一个内存中的地址；另一个是指针所指向的物，是这个地址中所存放着具有各种各样意义的数据。

　　2、对指针本身值的分析

　　下面例子考察指针本身的值（环境为32位的计算机）：

void *p = malloc( 100 );

　　请计算sizeof ( p ) = ?

char str[] = “Hello” ;
char *p = str ;

　　请计算sizeof ( p ) = ?

void Func ( char str[100])
{
请计算 sizeof( str ) = ? //注意，此时，str已经退化为一个指针，详情见
//下一篇指针与数组
}

　　分析：上面的例子，答案都是4，因为从上面的讨论可以知道，指针本身的值对应着内存中的一个地址，它的size只与机器的字长有关（即它是由系统的内存模型决定的），在32位机器中，这个长度是4个字节。

　　3、对指针所指向物的分析

　　现在再对指针这个复合类型的第二部分，指针所指向物的意义进行分析。

　　上面我们已经得到了指针本身的类型，那么将指针本身的类型去掉 “*”号就可得到指针所指向物的类型，分别如下：

　　a)、int

　　所指向物是一个整数。

　　b)、int*

　　所指向物是一个指向整数的指针。

　　c)、int ()[3]

　　()为空，可以去掉，变为int [3]，所指向物是一个拥有三个整数的数组。

　　d)、int ()()

　　第一个()为空，可以去掉，变为int (),所指向物是一个函数，这个函数的参数为空，返回值为整数。

　　4、附加分析

　　另外，关于指针本身大小的问题，在C++中与C有所不同，这里我也顺带谈一下。

　　在C++中，对于指向对象成员的指针，它的大小不一定是4个字节，这主要是因为在引入多重虚拟继承以及虚拟函数的时候，有些附加的信息也需要通过这个指针进行传递，因此指向对象成员的指针会增大，不论是指向成员数据，还是成员函数都是如此，具体与编译器的实现有关，你可以编写个很小的C++程序去验证一下。另外，对一个类的静态成员（static member，可以是静态成员变量或者静态成员函数）来说，指向它的指针只是普通的函数指针，而不是一个指向类成员的指针，所以它的大小不会增加，仍旧是4个字节。

　　指针运算符&和*

　　“&和*”，它们是一对相反的操作，’&’取得一个物的地址（也就是指针本身），’*’得到一个地址里放的物（指针所指向的物）。这个东西可以是值（对象）、函数、数组、类成员（class member）等等。

　　参照上面的分析我们可以很好地理解&与*。

　　使用指针的好处？

　　关于指针的本质和基本的运算符我们讨论过了，在这里，我想再笼总地谈一谈使用指针的必要性和好处，为我们今后的使用和对后面篇章的理解做好铺垫。简而言之，指针有以下好处：

　　1)、方便使用动态分配的数组。

　　这个解释我放在本系列第六篇中进行讲解。

　　2)、对于相同类型（甚至是相似类型）的多个变量进行通用访问。

　　就是用一个指针变量不断在多个变量之间指来指去，从而使得非常应用起来非常灵活，不过，这招也比较危险，需要小心使用：因为出现错误的指针是编程中非常忌讳的事情。

　　3)、变相改变一个函数的值传递特性。

　　说白了，就是指针的传地址作用，将一个变量的地址作为参数传给函数，这样函数就可以修改那个变量了。

　　4)、节省函数调用代价。

　　我们可以将参数，尤其是大个的参数（例如结构，对象等），将他们地址作为参数传给函数，这样可以省去编译器为它们制作副本所带来的空间和时间上的开销。

　　5)、动态扩展数据结构。

　　因为指针可以动态地使用malloc/new生成堆上的内存，所以在需要动态扩展数据结构的时候，非常有用；比如对于树、链表、Hash表等，这几乎是必不可少的特性。

　　6)、与目前计算机的内存模型相对应，可按照内存地址进行直接存取，这使得C非常适合于一些较底层的应用。

　　这也是C/C++指针一个强大的优点，我会在后面讲述C语言的底层操作时，较详细地介绍这个优点的应用。

　　7)、遍历数组。

　　据个例子来说吧，当你需要对字符串数组进行操作时，想一想，你当然要用字符串指针在字符串上扫来扫去。

　　…实在太多了，你可以慢慢来补充^_^。

　　指针本身的相关问题

　　1、问题：空指针的定义

　　曾经看过有的.h文件将NULL定义为0L，为什么？

　　答案与分析：

　　这是一个关于空指针宏定义的问题。指针在C语言中是经常使用的，有时需要将一个指针置为空指针，例如在指针变量初始化的时候。
C语言中的空指针和Pascal或者Lisp语言中的NIL具有相同的地位。那如何定义空指针呢？下面的语句是正确的：

char *p1 = 0;
int *p2;
if (p != 0)
{
...
}
p2 = 0;

　　也就是说，在指针变量的初始化、赋值、比较操作中，0会被编译器理解为要将指针置为空指针。至于空指针的内部表示是否是0，则随不同的机器类型而定，不过通常都是0。但是在另外一些场合下，例如函数的参数原型是指针类型，函数调用时如果将0作为参数传入，编译器则不能将其理解为空指针。此时需要明确的类型转换，例如：

void func (char *p);
func ((char *)0);

　　一般情况下，0是可以放在代码中和指针关联使用的，但是有些程序员（数量还不少呦！也许就包括你在内）不喜欢0的直白，认为其不能表示作为指针的特殊含义，于是要定义一个宏NULL，来明确表示空指针常量。这也是对的，人家C语言标准就明确说：“ NULL应该被定义为与实现相关的空指针常量”。但是将NULL定义成什么样的值呢？我想你一定见过好几种定义NULL的方法：

#define NULL 0
#define NULL (char *)0
#define NULL (void *)0

　　在我们使用的绝大多数计算系统上，例如PC，上述定义是能够工作的。然而，世界上还有很多其它种类的计算机，其CPU也不是Intel的。在某些系统上，指针和整数的大小和内部表示并不一致，甚至不同类型的指针的大小都不一致。为了避免这种可移植性问题，0L是一种最为安全的、最妥帖的定义方式。0L的含义是： “值为0的整数常量表达式”。这与C语言给出的空指针定义完全一致。因此，建议采用0L作为空指针常量NULL的值。

　　其实 NULL定义值，和操作系统的的平台有关， 将一个指针定义为 NULL， 其用意是为了保护操作系统，因为通过指针可以访问任何一块地址， 但是，有些数据是不许一般用户访问的，比如操作系统的核心数据。 当我们通过一个空(NULL)的指针去方位数据时，系统会提示非法， 那么系统又是如何知道的呢？？

　　以windows2000系统为例， 该系统规定系统中每个进程的起始地址（0x00000000）开始的某个地址范围内是存放系统数据的，用户进程无法访问， 所以当用户用空指针（0）访问时，其实访问的就是0x00000000地址的系统数据，由于该地址数据是受系统保护的，所以系统会提示错误(指针访问非法)。

　　这也就是说NULL值不一定要定义成0，起始只要定义在系统的保护范围的地址空间内，比如定义成(0x00000001, 0x00000002)都会起到相同的作用，但是为了考虑到移植性，普遍定义为0 。

　　2、问题：与指针相关的编程规则&规则分析

　　指针既然这么重要，而且容易出错，那么有没有方法可以很好地减少这些指针相关问题的出现呢？

　　答案与分析：

　　减少出错的根本是彻底理解指针。

　　在方法上，遵循一定的编码规则可能是最立竿见影的方法了，下面我来阐述一下与指针相关的编程规则：

　　1) 未使用的指针初始化为NULL 。

　　2) 在给指针分配空间前、分配后均应作判断。

　　3) 指针所指向的内容删除后也要清除指针本身。

　　要牢记指针是一个复合的数据结构这个本质，所以我们不论初始化和清除都要同时兼顾指针本身（上述规则1，3）和指针所指向的内容（上述规则2，3）这两个方面。

　　遵循这些规则可以有效地减少指针出错，我们来看下面的例子：

void Test(void)
{
　char *str = (char *) malloc(100);
　strcpy(str, “hello”);
　free(str);
　if(str != NULL)
　{
　　strcpy(str, “world”);
　　printf(str);
　}
}

　　请问运行Test函数会有什么样的结果？

　　答：

　　篡改动态内存区的内容，后果难以预料，非常危险。因为free(str);之后，str成为野指针，if(str != NULL)语句不起作用。

　　如果我们牢记规则3，在free(str)后增加语句：

str = NULL;

　　那么，就可以防止这样的错误发生。

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系统在处理这些文件时，并不区分类型，都看成是字符流，按字节进行处理。 输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。 因此也把这种文件称作“流式文件”。

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

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

　　文件打开函数fopen

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

　　fclose函数

　　调用的一般形式是： fclose(文件指针)； 例如：

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

　　在C语言中提供了多种文件读写的函数：

　　·字符读写函数 ：fgetc和fputc

　　·字符串读写函数：fgets和fputs

　　·数据块读写函数：freed和fwrite

　　·格式化读写函数：fscanf和fprinf

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

　　一、读字符函数fgetc

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

　　对于fgetc函数的使用有以下几点说明：

　　1. 在fgetc函数调用中，读取的文件必须是以读或读写方式打开的。

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

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

　　[例10.1]读入文件e10-1.c，在屏幕上输出。

#include<stdio.h>
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<stdio.h>
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<stdio.h>
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 %s\n",argv[1]);
getch();
exit(1);
}
if(argc==2) fp2=stdout;
else if((fp2=fopen(argv[2],"wt+"))==NULL)
{
printf("Cannot open %s\n",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和fputs

　　一、读字符串函数fgets函数的功能是从指定的文件中读一个字符串到字符数组中，函数调用的形式为： fgets(字符数组名，n，文件指针)； 其中的n是一个正整数。表示从文件中读出的字符串不超过 n-1个字符。在读入的最后一个字符后加上串结束标志'\0'。例如：fgets(str,n,fp);的意义是从fp所指的文件中读出n-1个字符送入字符数组str中。

　　[例10.4]从e10_1.c文件中读入一个含10个字符的字符串。

#include<stdio.h>
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数组，在数组最后一个单元内将加上'\0'，然后在屏幕上显示输出str数组。输出的十个字符正是例10.1程序的前十个字符。

　　对fgets函数有两点说明：

　　1. 在读出n-1个字符之前，如遇到了换行符或EOF，则读出结束。

　　2. fgets函数也有返回值，其返回值是字符数组的首地址。

　　二、写字符串函数fputs

　　fputs函数的功能是向指定的文件写入一个字符串，其调用形式为： fputs(字符串，文件指针) 其中字符串可以是字符串常量，也可以是字符数组名， 或指针 变量，例如：

fputs(“abcd“，fp)；

　　其意义是把字符串“abcd”写入fp所指的文件之中。[例10.5]在例10.2中建立的文件string中追加一个字符串。

#include<stdio.h>
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和fwrite

　　C语言还提供了用于整块数据的读写函数。 可用来读写一组数据，如一个数组元素，一个结构变量的值等。读数据块函数调用的一般形式为： 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<stdio.h>
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 data\n");
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("\n\nname\tnumber age addr\n");
for(i=0;i<2;i++,qq++)
printf("%s\t%5d%7d%s\n",qq->name,qq->num,qq->age,qq->addr);
fclose(fp);
}

　　本例程序定义了一个结构stu,说明了两个结构数组boya和 boyb以及两个结构指针变量pp和qq。pp指向boya,qq指向boyb。程序第16行以读写方式打开二进制文件“stu_list”，输入二个学生数据之后，写入该文件中， 然后把文件内部位置指针移到文件首，读出两块学生数据后，在屏幕上显示。

　　格式化读写函数fscanf和fprintf

　　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<stdio.h>
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 data\n");
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 %s\n",pp->name,pp->num,pp->age,pp->
addr);
rewind(fp);
for(i=0;i<2;i++,qq++)
fscanf(fp,"%s %d %d %s\n",qq->name,&qq->num,&qq->age,qq->addr);
printf("\n\nname\tnumber age addr\n");
qq=boyb;
for(i=0;i<2;i++,qq++)
printf("%s\t%5d %7d %s\n",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<stdio.h>
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("\n\nname\tnumber age addr\n");
　printf("%s\t%5d %7d %s\n",qq->name,qq->num,qq->age,
　qq->addr);
}

　　文件stu_list已由例10.6的程序建立，本程序用随机读出的方法读出第二个学生的数据。程序中定义boy为stu类型变量，qq为指向boy的指针。以读二进制文件方式打开文件，程序第22行移动文件位置指针。其中的i值为1，表示从文件头开始，移动一个stu类型的长度， 然后再读出的数据即为第二个学生的数据。

　　文件检测函数

　　C语言中常用的文件检测函数有以下几个。

　　一、文件结束检测函数feof函数调用格式： feof(文件指针)；

　　功能：判断文件是否处于文件结束位置，如文件结束，则返回值为1，否则为0。

　　二、读写文件出错检测函数ferror函数调用格式： ferror(文件指针)；

　　功能：检查文件在用各种输入输出函数进行读写时是否出错。 如ferror返回值为0表示未出错，否则表示有错。

　　三、文件出错标志和文件结束标志置0函数clearerr函数调用格式： clearerr(文件指针);

　　功能：本函数用于清除出错标志和文件结束标志，使它们为0值。

　　C库文件

　　C系统提供了丰富的系统文件，称为库文件，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 　　 说明一些串操作和内存操作函数。
SYS\STAT.H 　 定义在打开和创建文件时用到的一些符号常量。
SYS\TYPES.H 　说明ftime函数和timeb结构。
SYS\TIME.H 　 定义时间的类型time[ZZ(Z] [ZZ)]t。
TIME.H 　　　 定义时间转换子程序asctime、localtime和gmtime的结构，ctime、 difftime、 gmtime、 localtime和stime用到的类型，并提供这些函数的原型。
VALUE.H 　　　定义一些重要常量， 包括依赖于机器硬件的和为与Unix System V相兼容而说明的一些常量，包括浮点和双精度值的范围。

C语言程序设计基础之预处理
概述

　　在前面各章中，已多次使用过以“#”号开头的预处理命令。如包含命令# include，宏定义命令# define等。在源程序中这些命令都放在函数之外， 而且一般都放在源文件的前面，它们称为预处理部分。

　　所谓预处理是指在进行编译的第一遍扫描(词法扫描和语法分析)之前所作的工作。预处理是C语言的一个重要功能， 它由预处理程序负责完成。当对一个源文件进行编译时， 系统将自动引用预处理程序对源程序中的预处理部分作处理， 处理完毕自动进入对源程序的编译。

　　C语言提供了多种预处理功能，如宏定义、文件包含、 条件编译等。合理地使用预处理功能编写的程序便于阅读、修改、 移植和调试，也有利于模块化程序设计。本章介绍常用的几种预处理功能。

　　宏定义

　　在C语言源程序中允许用一个标识符来表示一个字符串， 称为“宏”。被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换， 这称为“宏代换”或“宏展开”。

　　宏定义是由源程序中的宏定义命令完成的。 宏代换是由预处理程序自动完成的。在C语言中，“宏”分为有参数和无参数两种。 下面分别讨论这两种“宏”的定义和调用。

　　无参宏定义

　　无参宏的宏名后不带参数。其定义的一般形式为： #define 标识符 字符串 其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。 “标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。在前面介绍过的符号常量的定义就是一种无参宏定义。 此外，常对程序中反复使用的表达式进行宏定义。例如： # define M (y*y+3*y) 定义M表达式(y*y+3*y)。在编写源程序时，所有的(y*y+3*y)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(y*y+3*y)表达式去置换所有的宏名M，然后再进行编译。

#define M (y*y+3*y)
main(){
　int s,y;
　printf("input a number: ");
　scanf("%d",&y);
　s=3*M+4*M+5*M;
　printf("s=%d\n",s);
}

　　上例程序中首先进行宏定义，定义M表达式(y*y+3*y),在s= 3*M+4*M+5* M中作了宏调用。在预处理时经宏展开后该语句变为：s=3*(y*y+3*y)+4(y*y+3*y)+5(y*y+3*y);但要注意的是，在宏定义中表达式(y*y+3*y)两边的括号不能少。否则会发生错误。

　　当作以下定义后： #difine M y*y+3*y在宏展开时将得到下述语句： s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y；这相当于； 3y?2+3y+4y?2+3y+5y?2+3y；显然与原题意要求不符。计算结果当然是错误的。 因此在作宏定义时必须十分注意。应保证在宏代换之后不发生错误。对于宏定义还要说明以下几点：

　　1. 宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。

　　2. 宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。

　　3. 宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结 束。如要终止其作用域可使用# undef命令，例如：

# define PI 3.14159
main()
{
……
}

　　# undef PIPI的作用域

　　f1()

　　....表示PI只在main函数中有效，在f1中无效。

　　4. 宏名在源程序中若用引号括起来，则预处理程序不对其作宏代换。

#define OK 100
main()
{
　printf("OK");
　printf("\n");
}

　　上例中定义宏名OK表示100，但在printf语句中OK被引号括起来，因此不作宏代换。程序的运行结果为：OK这表示把“OK”当字符串处理。

　　5. 宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名。在宏展开时由预处理程序层层代换。例如：

#define PI 3.1415926
#define S PI*y*y /* PI是已定义的宏名*/对语句： printf("%f",s);

　　在宏代换后变为： printf("%f",3.1415926*y*y);

　　6. 习惯上宏名用大写字母表示，以便于与变量区别。但也允许用小写字母。

　　7. 可用宏定义表示数据类型，使书写方便。例如： #define STU struct stu在程序中可用STU作变量说明：

STU body[5],*p;#define INTEGER int
　　
　　在程序中即可用INTEGER作整型变量说明： INTEGER a,b; 应注意用宏定义表示数据类型和用typedef定义数据说明符的区别。宏定义只是简单的字符串代换，是在预处理完成的，而typedef是在编译时处理的，它不是作简单的代换， 而是对类型说明符重新命名。被命名的标识符具有类型定义说明的功能。请看下面的例子： #define PIN1 int*　typedef (int*) PIN2;从形式上看这两者相似， 但在实际使用中却不相同。下面用PIN1，PIN2说明变量时就可以看出它们的区别： PIN1 a,b;在宏代换后变成 int *a,b;表示a是指向整型的指针变量，而b是整型变量。然而：PIN2 a,b;表示a,b都是指向整型的指针变量。因为PIN2是一个类型说明符。由这个例子可见，宏定义虽然也可表示数据类型， 但毕竟是作字符代换。在使用时要分外小心，以避出错。

　　8. 对“输出格式”作宏定义，可以减少书写麻烦。例9.3 中就采用了这种方法。

#define P printf
#define D "%d\n"
#define F "%f\n"
main(){
int a=5, c=8, e=11;
float b=3.8, d=9.7, f=21.08;
P(D F,a,b);
P(D F,c,d);
P(D F,e,f);
}

　　带参宏定义

　　C语言允许宏带有参数。在宏定义中的参数称为形式参数， 在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开， 而且要用实参去代换形参。

　　带参宏定义的一般形式为： #define 宏名(形参表) 字符串 在字符串中含有各个形参。带参宏调用的一般形式为： 宏名(实参表)；
例如：

#define M(y) y*y+3*y /*宏定义*/
:
k=M(5); /*宏调用*/
: 在宏调用时，用实参5去代替形参y， 经预处理宏展开后的语句
为： k=5*5+3*5
#define MAX(a,b) (a>b)?a:b
main(){
int x,y,max;
printf("input two numbers: ");
scanf("%d%d",&x,&y);
max=MAX(x,y);
printf("max=%d\n",max);
}

　　上例程序的第一行进行带参宏定义，用宏名MAX表示条件表达式(a>b)?a:b，形参a,b均出现在条件表达式中。程序第七行max=MAX(x,
y)为宏调用，实参x,y，将代换形参a,b。宏展开后该语句为： max=(x>y)?x:y;用于计算x,y中的大数。对于带参的宏定义有以下问题需要说明：

　　1. 带参宏定义中，宏名和形参表之间不能有空格出现。

　　例如把： #define MAX(a,b) (a>b)?a:b写为： #define MAX (a,b) (a>b)?a:b 将被认为是无参宏定义，宏名MAX代表字符串 (a,b)(a>b)?a:b。

　　宏展开时，宏调用语句： max=MAX(x,y);将变为： max=(a,b)(a>b)?a:b(x,y);这显然是错误的。

　　2. 在带参宏定义中，形式参数不分配内存单元，因此不必作类型定义。而宏调用中的实参有具体的值。要用它们去代换形参，因此必须作类型说明。这是与函数中的情况不同的。在函数中，形参和实参是两个不同的量，各有自己的作用域，调用时要把实参值赋予形参，进行“值传递”。而在带参宏中，只是符号代换，不存在值传递的问题。

　　3. 在宏定义中的形参是标识符，而宏调用中的实参可以是表达式。

#define SQ(y) (y)*(y)
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
}

　　上例中第一行为宏定义，形参为y。程序第七行宏调用中实参为a+1，是一个表达式，在宏展开时，用a+1代换y，再用(y)*(y) 代换SQ，得到如下语句： sq=(a+1)*(a+1); 这与函数的调用是不同的， 函数调用时要把实参表达式的值求出来再赋予形参。 而宏代换中对实参表达式不作计算直接地照原样代换。

　　4. 在宏定义中，字符串内的形参通常要用括号括起来以避免出错。 在上例中的宏定义中(y)*(y)表达式的y都用括号括起来，因此结果是正确的。如果去掉括号，把程序改为以下形式：

#define SQ(y) y*y
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
}

　　运行结果为：input a number:3

　　sq=7 同样输入3，但结果却是不一样的。问题在哪里呢? 这是由于代换只作符号代换而不作其它处理而造成的。 宏代换后将得到以下语句： sq=a+1*a+1; 由于a为3故sq的值为7。这显然与题意相违，因此参数两边的括号是不能少的。即使在参数两边加括号还是不够的，请看下面程序：

#define SQ(y) (y)*(y)
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=160/SQ(a+1);
printf("sq=%d\n",sq);
}

　　本程序与前例相比，只把宏调用语句改为： sq=160/SQ(a+1); 运行本程序如输入值仍为3时，希望结果为10。但实际运行的结果如下：input a number:3　sq=160为什么会得这样的结果呢?分析宏调用语句，在宏代换之后变为： sq=160/(a+1)*(a+1);a为3时，由于“/”和“*”运算符优先级和结合性相同， 则先作160/(3+1)得40，再作40*(3+1)最后得160。为了得到正确答案应在宏定义中的整个字符串外加括号， 程序修改如下

#define SQ(y) ((y)*(y))
main(){
　int a,sq;
　printf("input a number: ");
　scanf("%d",&a);
　sq=160/SQ(a+1);
　printf("sq=%d\n",sq);
}

　　以上讨论说明，对于宏定义不仅应在参数两侧加括号， 也应在整个字符串外加括号。

　　5. 带参的宏和带参函数很相似，但有本质上的不同，除上面已谈到的各点外，把同一表达式用函数处理与用宏处理两者的结果有可能是不同的。

main(){
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
}
SQ(int y)
{
　return((y)*(y));
}#define SQ(y) ((y)*(y))
main(){
　int i=1;
　while(i<=5)
　　printf("%d\n",SQ(i++));
}

　　在上例中函数名为SQ，形参为Y，函数体表达式为((y)*(y))。在例9.6中宏名为SQ，形参也为y，字符串表达式为(y)*(y))。 两例是相同的。例9.6的函数调用为SQ(i++)，例9.7的宏调用为SQ(i++)，实参也是相同的。从输出结果来看，却大不相同。分析如下：在例9.6中，函数调用是把实参i值传给形参y后自增1。 然后输出函数值。因而要循环5次。输出1～5的平方值。而在例9.7中宏调用时，只作代换。SQ(i++)被代换为((i++)*(i++))。在第一次循环时，由于i等于1，其计算过程为：表达式中前一个i初值为1，然后i自增1变为2，因此表达式中第2个i初值为2，两相乘的结果也为2，然后i值再自增1，得3。在第二次循环时，i值已有初值为3，因此表达式中前一个i为3，后一个i为4， 乘积为12，然后i再自增1变为5。进入第三次循环，由于i 值已为5，所以这将是最后一次循环。计算表达式的值为5*6等于30。i值再自增1变为6，不再满足循环条件，停止循环。从以上分析可以看出函数调用和宏调用二者在形式上相似， 在本质上是完全不同的。

　　6. 宏定义也可用来定义多个语句，在宏调用时，把这些语句又代换到源程序内。看下面的例子。

#define SSSV(s1,s2,s3,v) s1=l*w;s2=l*h;s3=w*h;v=w*l*h;
main(){
　int l=3,w=4,h=5,sa,sb,sc,vv;
　SSSV(sa,sb,sc,vv);
　printf("sa=%d\nsb=%d\nsc=%d\nvv=%d\n",sa,sb,sc,vv);
}

　　程序第一行为宏定义，用宏名SSSV表示4个赋值语句，4 个形参分别为4个赋值符左部的变量。在宏调用时，把4 个语句展开并用实参代替形参。使计算结果送入实参之中。

　　文件包含

　　文件包含是C预处理程序的另一个重要功能。文件包含命令行的一般形式为： #include"文件名" 在前面我们已多次用此命令包含过库函数的头文件。例如：

#include"stdio.h"
#include"math.h"

　　文件包含命令的功能是把指定的文件插入该命令行位置取代该命令行， 从而把指定的文件和当前的源程序文件连成一个源文件。在程序设计中，文件包含是很有用的。 一个大的程序可以分为多个模块，由多个程序员分别编程。 有些公用的符号常量或宏定义等可单独组成一个文件， 在其它文件的开头用包含命令包含该文件即可使用。这样，可避免在每个文件开头都去书写那些公用量， 从而节省时间，并减少出错。

　　对文件包含命令还要说明以下几点：

　　1. 包含命令中的文件名可以用双引号括起来，也可以用尖括号括起来。例如以下写法都是允许的： #include"stdio.h"　#include<math.h> 但是这两种形式是有区别的：使用尖括号表示在包含文件目录中去查找(包含目录是由用户在设置环境时设置的)， 而不在源文件目录去查找； 使用双引号则表示首先在当前的源文件目录中查找，若未找到才到包含目录中去查找。 用户编程时可根据自己文件所在的目录来选择某一种命令形式。

　　2. 一个include命令只能指定一个被包含文件， 若有多个文件要包含，则需用多个include命令。3. 文件包含允许嵌套，即在一个被包含的文件中又可以包含另一个文件。

　　条件编译

　　预处理程序提供了条件编译的功能。 可以按不同的条件去编译不同的程序部分，因而产生不同的目标代码文件。 这对于程序的移植和调试是很有用的。 条件编译有三种形式，下面分别介绍：

　　1. 第一种形式：

#ifdef 标识符
程序段1
#else
程序段2
#endif

　　它的功能是，如果标识符已被 #define命令定义过则对程序段1进行编译；否则对程序段2进行编译。如果没有程序段2(它为空)，本格式中的#else可以没有， 即可以写为：

#ifdef 标识符
程序段 #endif
#define NUM ok
main(){
　struct stu
　{
　　int num;
　　char *name;
　　char sex;
　　float score;
　} *ps;
　ps=(struct stu*)malloc(sizeof(struct stu));
　ps->num=102;
　ps->name="Zhang ping";
　ps->sex='M';
　ps->score=62.5;
　#ifdef NUM
　　printf("Number=%d\nScore=%f\n",ps->num,ps->score);
　#else
　　printf("Name=%s\nSex=%c\n",ps->name,ps->sex);
　#endif
　free(ps);
}

　　由于在程序的第16行插入了条件编译预处理命令， 因此要根据NUM是否被定义过来决定编译那一个printf语句。而在程序的第一行已对NUM作过宏定义，因此应对第一个printf语句作编译故运行结果是输出了学号和成绩。在程序的第一行宏定义中，定义NUM表示字符串OK，其实也可以为任何字符串，甚至不给出任何字符串，写为： #define NUM 也具有同样的意义。 只有取消程序的第一行才会去编译第二个printf语句。读者可上机试作。

　　2. 第二种形式：

#ifndef 标识符
程序段1
#else
程序段2
#endif

　　与第一种形式的区别是将“ifdef”改为“ifndef”。它的功能是，如果标识符未被#define命令定义过则对程序段1进行编译， 否则对程序段2进行编译。这与第一种形式的功能正相反。

　　3. 第三种形式：

#if 常量表达式
程序段1
#else
程序段2
#endif

　　它的功能是，如常量表达式的值为真(非0)，则对程序段1 进行编译，否则对程序段2进行编译。因此可以使程序在不同条件下，完成不同的功能

#define R 1
main(){
　float c,r,s;
　printf ("input a number: ");
　scanf("%f",&c);
　#if R
　　r=3.14159*c*c;
　　printf("area of round is: %f\n",r);
　#else
　　s=c*c;
　　printf("area of square is: %f\n",s);
　#endif
}

　　本例中采用了第三种形式的条件编译。在程序第一行宏定义中，定义R为1，因此在条件编译时，常量表达式的值为真， 故计算并输出圆面积。上面介绍的条件编译当然也可以用条件语句来实现。 但是用条件语句将会对整个源程序进行编译，生成的目标代码程序很长，而采用条件编译，则根据条件只编译其中的程序段1或程序段2， 生成的目标程序较短。如果条件选择的程序段很长， 采用条件编译的方法是十分必要的。

C语言程序设计基础之枚举与位运算

在实际问题中， 有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有七天，一年只有十二个月， 一个班每周有六门课程等等。如果把这些量说明为整型， 字符型或其它类型显然是不妥当的。 为此，C语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值， 被说明为该“枚举”类型的变量取值不能超过定义的范围。应该说明的是， 枚举类型是一种基本数据类型，而不是一种构造类型， 因为它不能再分解为任何基本类型。

　　枚举类型的定义和枚举变量的说明

　　一、枚举的定义

　　枚举类型定义的一般形式为：

enum 枚举名
{
　枚举值表
};

　　在枚举值表中应罗列出所有可用值。这些值也称为枚举元素。

　　例如：

enum weekday
{
　sun,mou,tue,wed,thu,fri,sat
};

　　该枚举名为weekday，枚举值共有7个，即一周中的七天。 凡被说明为weekday类型变量的取值只能是七天中的某一天。

　　二、枚举变量的说明

　　如同结构和联合一样，枚举变量也可用不同的方式说明， 即先定义后说明，同时定义说明或直接说明。设有变量a,b,c被说明为上述的weekday，可采用下述任一种方式：

enum weekday
{
......
};
enum weekday a,b,c;或者为： enum weekday
{
......
}a,b,c;或者为： enum
{
......
}a,b,c;

　　枚举类型变量的赋值和使用

　　枚举类型在使用中有以下规定：

　　1. 枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。例如对枚举weekday的元素再作以下赋值： sun=5;mon=2;sun=mon; 都是错误的。

　　2. 枚举元素本身由系统定义了一个表示序号的数值，从0 开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1， …,sat值为6。

main(){
　enum weekday
　{
　　sun,mon,tue,wed,thu,fri,sat
　} a,b,c;
　a=sun;
　b=mon;
　c=tue;
　printf("%d,%d,%d",a,b,c);
}

　　3. 只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如： a=sum;b=mon; 是正确的。而： a=0;b=1; 是错误的。如一定要把数值赋予枚举变量，则必须用强制类型转换，如： a=(enum weekday)2;其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于： a=tue; 还应该说明的是枚举元素不是字符常量也不是字符串常量， 使用时不要加单、双引号。

main(){
　enum body
　{
　　a,b,c,d
　} month[31],j;
　int i;
　j=a;
　for(i=1;i<=30;i++){
　　month[i]=j;
　　j++;
　　if (j>d) j=a;
　}
　for(i=1;i<=30;i++){
　　switch(month[i])
　　{
　　　case a:printf(" %2d %c\t",i,'a'); break;
　　　case b:printf(" %2d %c\t",i,'b'); break;
　　　case c:printf(" %2d %c\t",i,'c'); break;
　　　case d:printf(" %2d %c\t",i,'d'); break;
　　　default:break;
　　}
　}
　printf("\n");
}

　　位运算

　　前面介绍的各种运算都是以字节作为最基本位进行的。 但在很多系统程序中常要求在位(bit)一级进行运算或处理。C语言提供了位运算的功能， 这使得C语言也能像汇编语言一样用来编写系统程序。

　　一、位运算符C语言提供了六种位运算符：

　　& 按位与
　　| 按位或
　　^ 按位异或
　　~ 取反
　　<< 左移
　　>> 右移

　　1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。

　　例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码)　00000001 (1的二进制补码)可见9&5=1。

　　按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。

main(){
　int a=9,b=5,c;
　c=a&b;
　printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}

　　2. 按位或运算 按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。

　　 例如：9|5可写算式如下：

00001001|00000101
00001101 (十进制为13)可见9|5=13
main(){
　int a=9,b=5,c;
　c=a|b;
　printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}

　　3. 按位异或运算 按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下：

00001001^00000101 00001100 (十进制为12)
main(){
　int a=9;
　a=a^15;
　printf("a=%d\n",a);
}

　　4. 求反运算 求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(0000000000001001)结果为：1111111111110110

　　5. 左移运算 左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，

　　高位丢弃，低位补0。例如： a<<4 指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。6. 右移运算 右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。

　　例如：设 a=15，a>>2　表示把000001111右移为00000011(十进制3)。 应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。

main(){
　unsigned a,b;
　printf("input a number: ");
　scanf("%d",&a);
　b=a>>5;
　b=b&15;
　printf("a=%d\tb=%d\n",a,b);
}

　　请再看一例!

main(){
　char a='a',b='b';
　int p,c,d;
　p=a;
　p=(p<<8)|b;
　d=p&0xff;
　c=(p&0xff00)>>8;
　printf("a=%d\nb=%d\nc=%d\nd=%d\n",a,b,c,d);
}

　　位域

　　有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，C语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域， 并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：

　　struct 位域结构名

　　{ 位域列表 };

　　其中位域列表的形式为： 类型说明符 位域名：位域长度

　　例如：

struct bs
{
　int a:8;
　int b:2;
　int c:6;
};

　　位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：

struct bs
{
　int a:8;
　int b:2;
　int c:6;
}data;

　　说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：

　　1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

struct bs
{
　unsigned a:4
　unsigned :0 /*空域*/
　unsigned b:4 /*从下一单元开始存放*/
　unsigned c:4
}

　　在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。

　　2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。

　　3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：

struct k
{
　int a:1
　int :2 /*该2位不能使用*/
　int b:3
　int c:2
};

　　从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。

　　二、位域的使用

　　位域的使用和结构成员的使用相同，其一般形式为： 位域变量名·位域名 位域允许用各种格式输出。

main(){
　struct bs
　{
　　unsigned a:1;
　　unsigned b:3;
　　unsigned c:4;
　} bit,*pbit;
　bit.a=1;
　bit.b=7;
　bit.c=15;
　printf("%d,%d,%d\n",bit.a,bit.b,bit.c);
　pbit=&bit;
　pbit->a=0;
　pbit->b&=3;
　pbit->c|=1;
　printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);
}

　　上例程序中定义了位域结构bs，三个位域为a,b,c。说明了bs类型的变量bit和指向bs类型的指针变量pbit。这表示位域也是可以使用指针的。

　　程序的9、10、11三行分别给三个位域赋值。( 应注意赋值不能超过该位域的允许范围)程序第12行以整型量格式输出三个域的内容。第13行把位域变量bit的地址送给指针变量pbit。第14行用指针方式给位域a重新赋值，赋为0。第15行使用了复合的位运算符"&="， 该行相当于： pbit->b=pbit->b&3位域b中原有值为7，与3作按位与运算的结果为3(111&011=011,十进制值为3)。同样，程序第16行中使用了复合位运算"|="， 相当于： pbit->c=pbit->c|1其结果为15。程序第17行用指针方式输出了这三个域的值。

　　类型定义符typedef

　　C语言不仅提供了丰富的数据类型，而且还允许由用户自己定义类型说明符，也就是说允许由用户为数据类型取“别名”。 类型定义符typedef即可用来完成此功能。例如，有整型量a,b,其说明如下： int aa,b; 其中int是整型变量的类型说明符。int的完整写法为integer，

　　为了增加程序的可读性，可把整型说明符用typedef定义为： typedef int INTEGER 这以后就可用INTEGER来代替int作整型变量的类型说明了。 例如： INTEGER a,b;它等效于： int a,b; 用typedef定义数组、指针、结构等类型将带来很大的方便，不仅使程序书写简单而且使意义更为明确，因而增强了可读性。例如：

typedef char NAME[20]; 表示NAME是字符数组类型，数组长度为20。

　　然后可用NAME 说明变量，如： NAME a1,a2,s1,s2;完全等效于： char a1[20],a2[20],s1[20],s2[20]
又如：

typedef struct stu{ char name[20];
　int age;
　char sex;
} STU;

　　定义STU表示stu的结构类型，然后可用STU来说明结构变量： STU body1,body2;

　　typedef定义的一般形式为： typedef 原类型名 新类型名 其中原类型名中含有定义部分，新类型名一般用大写表示， 以便于区别。在有时也可用宏定义来代替typedef的功能，但是宏定义是由预处理完成的，而typedef则是在编译时完成的，后者更为灵活方便。

to:nuciewth版主 在那里得到

刚好逛一些网站的时候看到的,所以就窃了过来.

正好需要这个，c以前学的，好多都有点遗忘了。谢谢搂住了