[C++知识库]C语言系列：7、输入与输出

C语言系列：7、输入与输出

ANSI标准精确地定义了这些库函数，所以，在任何可以使用C语言的系统中都有这些函数的兼容形式。如果程序的系统交互部分仅仅使用了标准库提供的功能，则可以不经修改地从一个系统移植到另一个系统中。

这些库函数的属性分别在十多个头文件中声明，前面已经遇到过一部分，如<stdio.h>、<string.h>和<ctype.h>。我们不打算把整个标准库都罗列于此，因为我们更关心如何使用标准库编写C语言程序。附录B对标准库进行了详细的描述。

1. 标准输入/输出

我们在第1 章中讲过，标准库实现了简单的文本输入／输出模式。文本流由一系列行组成，每一行的结尾是一个换行符。如果系统没有遵循这种模式，则标准库将通过一些措施使得该系统适应这种模式。例如，标准库可以在输入端将回车符和换行符都转换为换行符，而在输出端进行反向转换。

1.1 标准输入

最简单的输入机制是使用getchar函数从标准输入中（一般为键盘）一次读取一个字符：

int getchar(void)

getchar函数在每次被调用时返回下一个输入字符。若遇到文件结尾，则返回EOF。符号常量EOF在头文件<stdio.h>中定义，其值一般为-1，但程序中应该使用EOF来测试文件是否结束，这样才能保证程序同EOF的特定值无关。

在许多环境中，可以使用符号<来实现输入重定向，它将把键盘输入替换为文件输入：如果程序prog中使用了函数getchar，则命令行

prog < infile

将使得程序prog从输入文件infile（而不是从键盘）中读取字符。实际上，程序prog本身并不在意输入方式的改变，并且，字符串"<infile"也并不包含在argv的命令行参数中。如果输入通过管道机制来自于另一个程序，那么这种输入切换也是不可见的。比如，在某些系统中，下列命令行：

otherprog | prog

将运行两个程序otherprog和prog，并将程序otherprog的标准输出通过管道重定向到程序prog的标准输入上。

1.2 标准输出

函数

int putchar(int)

用于输出数据。putchar?将字符c 送至标准输出上，在默认情况下，标准输出为屏幕显示。如果没有发生错误，则函数putchar将返同输出的字符；如果发生了错误，则返回EOF。同样，通常情况下，也可以使用“>输出文件名”的格式将输出重定向到某个文件中。例如，如果程序prog调用了函数putchar，那么命令行

prog > 输出文件名

将把程序prog的输出从标准输出设备重定向到文件中。如果系统支持管道，那么命令行

prog | anotherprog

将把程序prog的输出从标准输出通过管道重定向到程序anotherprog的标准输入中。

1.3 printf

函数 printf也向标准输出设备上输出数据。我们在程序中可以交叉调用函数putchar和printf，输出将按照函数调用的先后顺序依次产生。

使用输入／输出库函数的每个源程序文件必须在引用这些函数之前包含下列语句

#include <stdio.h>

当文件名用一对尖括号<和>括起来时，预处理器将在由具体实现定义的有关位置中查找指定的文件（例如，在UNIX 系统中，文件一般放在目录/usr/include中）。

1.4 示例

许多程序只从一个输入流中读取数据，并且只向一个输出流中输出数据。对于这样的程序，只需要使用函数getchar、putchar 和printf 实现输入／输出即可，并且对程序来说已经足够了。特别是，如果通过重定向将一个程序的输出连接到另一个程序的输入，仅仅使用这些函数就足够了。例如，考虑下列程序lower，它用于将输入转换为小写字母的形式：

#include <stdio.h>
#include <ctype.h>
main() /* lower: convert input to lower case*/
{
    int c
        while ((c = getchar()) != EOF)
            putchar(tolower(c));
    return 0;
}

函数tolower 在头文件<ctype.h>中定义，它把大写字母转换为小写形式，并把其它
字符原样返回。我们在前面提到过，头文件<stdio.h>中的getchar和putchar“函数”
以及<ctype.h>中的tolower“函数”一般都是宏，这样就避免了对每个字符都进行函数调用的开销。我们将在8.5 节介绍它们的实现方法。无论<ctype.h>中的函数在给定的机器上是如何实现的，使用这些函数的程序都不必了解字符集的知识。

2. 格式化输出–printf函数

输出函数 printf将内部数值转换为字符的形式。前面的有关章节中已经使用过该函数。

下面只讲述该函数最典型的用法，附录B中给出了该函数完整的描述。

int printf(char *format, arg1, arg2, ...);

函数printf 在输出格式format 的控制下，将其参数进行转换与格式化，并在标准输出设备上打印出来。它的返回值为打印的字符数。

格式字符串包含两种类型的对象：普通字符和转换说明。在输出时，普通字符将原样不动地复制到输出流中，而转换说明并不直接输出到输出流中，而是用于控制printf 中参数的转换和打印，每个转换说明都由一个百分号字符（即%）开始，并以一个转换字符结束。在字符%和转换字符中间可能依次包含下列组成部分：

• 负号，用于指定被转换的参数按照左对齐的形式输出。

• 数，用于指定最小字段宽度。转换后的参数将打印不小于最小字段宽度的字段。如果有必要，字段左边（如果使用左对齐的方式，则为右边）多余的字符位置用空格填充以保证最小字段宽。

• 小数点，用于将字段宽度和精度分开。

• 数，用于指定精度，即指定字符串中要打印的最大字符数、浮点数小数点后的位数、整型最少输出的数字数目。

• 字母h或l，字母h表不将整数作为short类型打印，字母l表示将整数作为long类型打印。

表 7-1 列出了所有的转换字符，如果%后面的字符不是一个转换说明，则该行为是未定义的。

表 7-1 printf函数基本的转换说明

在转换说明中，宽度或精度可以用星号*表示，这时，宽度或精度的值通过转换下一参数（必须为int类型）来计算。例如，为了从字符串s中打印最多max个字符，可以使用下列语句：

printf("%.*s", max, s);

前面的章节中已经介绍过大部分的格式转换，但没有介绍与字符串相关的精度。下表说明了在打印字符串"hello, world"（12 个字符）时根据不同的转换说明产生的不同结果。

我们在每个字段的左边和右边加上冒号，这样可以清晰地表示出字段的宽度。

:%s: :hello, world:
:%10s: :hello, world:
:%.10s: :hello, wor:
:%-10s: :hello, world:
:%.15s: :hello, world:
:%-15s: :hello, world :
:%15.10s: : hello, wor:
:%-15.10s: :hello, wor :

注意：函数printf 使用第一个参数判断后面参数的个数及类型。如果参数的个数不够或者类型错误，则将得到错误的结果。请注意下面两个函数调用之间的区别：

printf(s); /* FAILS if s contains % */
printf("%s", s); /* SAFE */

函数sprintf执行的转换和函数printf相同，但它将输出保存到一个字符串中：

int sprintf(char *string, char *format, arg1, arg2, ...);

sprintf函数和printf函数一样，按照format 格式格式化参数序列arg1、arg2、…，
但它将输出结果存放到string中，而不是输出到标准输出中。当然，string必须足够大以存放输出结果。

3. 变长参数表

本节以实现函数printf 的一个最简单版本为例，介绍如何以可移植的方式编写可处理变长参数表的函数。因为我们的重点在于参数的处理，所以，函数minprintf只处理格式字符串和参数，格式转换则通过调用函数printf实现。

函数 printf的正确声明形式为：

int printf(char *fmt, ...)

其中，省略号表示参数表中参数的数量和类型是可变的。省略号只能出现在参数表的尾部。因为minprintf 函数不需要像printf 函数一样返回实际输出的字符数，因此，我们将它声明为下列形式：

void minprintf(char *fmt, ...)

编写函数minprintf的关键在于如何处理一个甚至连名字都没有的参数表。标准头文件<stdarg.h）中包含一组宏定义，它们对如何遍历参数表进行了定义。该头文件的实现因不同的机器而不同，但提供的接口是一致的。

va_list类型用于声明一个变量，该变量将依次引用各参数。在函数minprintf 中，
我们将该变量称为ap，意思是“参数指针”。宏va_start将ap初始化为指向第一个无名参数的指针。在使用ap 之前，该宏必须被调用一次。参数表必须至少包括一个有名参数，va_start将最后一个有名参数作为起点。

每次调用va_arg，该函数都将返回一个参数，并将ap 指向下一个参数。va_arg 使用
一个类型名来决定返回的对象类型、指针移动的步长。最后，必须在函数返回之前调用va_end，以完成一些必要的清理工作。

基于上面这些讨论，我们实现的简化printf函数如下所示：

#include <stdarg.h>
/* minprintf: minimal printf with variable argument list */
void minprintf(char *fmt, ...)
{
    va_list ap; /* points to each unnamed arg in turn */
    char *p, *sval;
    int ival;
    double dval;
    va_start(ap, fmt); /* make ap point to 1st unnamed arg */
    for (p = fmt; *p; p++) {
        if (*p != '%') {
            putchar(*p);
            continue;
        }
        switch (*++p) {
            case 'd':
                ival = va_arg(ap, int);
                printf("%d", ival);
                break;
            case 'f':
                dval = va_arg(ap, double);
                printf("%f", dval);
                break;
            case 's':
                for (sval = va_arg(ap, char *); *sval; sval++)
                    putchar(*sval);
                break;
            default:
                putchar(*p);
                break;
        }
    }
    va_end(ap); /* clean up when done */
}

4. 格式化输入–scanf函数

输入函数 scanf 对应于输出函数printf，它在与后者相反的方向上提供同样的转换功能。具有变长参数表的函数scanf的声明形式如下：

int scanf(char *format, ...)

scanf 函数从标准输入中读取字符序列，按照format 中的格式说明对字符序列进行解释，并把结果保存到其余的参数中。格式参数format 将在接下来的内容中进行讨论。其它所有参数都必须是指针，用于指定经格式转换后的相应输入保存的位置。和上节讲述printf 一样，本节只介绍scanf函数最有用的一些特征，而并不完整地介绍。

当 scanf函数扫描完其格式串，或者碰到某些输入无法与格式控制说明匹配的情况时，该函数将终止，同时，成功匹配并赋值的输入项的个数将作为函数值返回，所以，该函数的返回值可以用来确定已匹配的输入项的个数。如果到达文件的结尾，该函数将返回EOF。注意，返回EOF 与0 是不同的，0 表示下一个输入字符与格式串中的第一个格式说明不匹配。下一次调用scanf函数将从上一次转换的最后一个字符的下一个字符开始继续搜索。

另外还有一个输入函数sscanf，它用于从一个字符串（而不是标准输入）中读取字符序列：

int sscanf(char *string, char *format, arg1, arg2, ...)

它按照格式参数format 中规定的格式扫描字符串string，并把结果分别保存到arg1、arg2、…这些参数中。这些参数必须是指针。

格式串通常都包含转换说明，用于控制输入的转换。格式串可能包含下列部分：

• 空格或制表符，在处理过程中将被忽略。
• 普通字符（不包括%），用于匹配输入流中下一个非空白符字符。
• 转换说明，依次由一个%、一个可选的赋值禁止字符*、一个可选的数值（指定最大字段宽度）、一个可选的h、l 或L 字符（指定目标对象的宽度）以及一个转换字符组成。

转换说明控制下一个输入字段的转换。一般来说，转换结果存放在相应的参数指向的变量中。但是，如果转换说明中有赋值禁止字符*，则跳过该输入字段，不进行赋值。输入字段定义为一个不包括空白符的字符串，其边界定义为到下一个空白符或达到指定的字段宽度。这表明scanf 函数将越过行边界读取输入，因为换行符也是空白符。（空白符包括空格符、横向制表符、换行符、回车符、纵向制表符以及换页符）。

转换字符指定对输入字段的解释。对应的参数必须是指针，这也是C 语言通过值调用语义所要求的。表7-2 中列出了这些转换字符。

表 7-2 scanf函数的基本转换说明

转换说明d、i、o、u 及x 的前面可以加上字符h 或l。前缀h 表明参数表的相应参数
是一个指向short类型而非int类型的指针，前缀l表明参数表的相应参数是一个指向long类型的指针。类似地，转换说明e、f和g的前面也可以加上前缀l，它表明参数表的相应参数是一个指向double类型而非float类型的指针。

来看第一个例子。我们通过函数scanf执行输入转换来改写第4 章中的简单计算器程序，如下所示：

#include <stdio.h>
main() /* rudimentary calculator */
{
    double sum, v;
    sum = 0;
    while (scanf("%lf", &v) == 1)
        printf("\t%.2f\n", sum += v);
    return 0;
}

假设我们要读取包含下列日期格式的输入行：

25 Dec 1988

相应的scanf语句可以这样编写：

int day, year;
char monthname[20];
scanf("%d %s %d", &day, monthname, &year);

因为数组名本身就是指针，所以，monthname的前面没有取地址运算符&。

字符字面值也可以出现在scanf的格式串中，它们必须与输入中相同的字符匹配。因此，我们可以使用下列scanf语句读入形如mm/dd/yy 的日期数据：

int day, month, year;
scanf("%d/%d/%d", &month, &day, &year);

scanf函数忽略格式串中的空格和制表符。此外，在读取输入值时，它将跳过空白符（空格、制表符、换行符等等）。如果要读取格式不固定的输入，最好每次读入一行，然后再用sscanf将合适的格式分离出来读入。例如，假定我们需要读取一些包含日期数据的输入行，日期的格式可能是上述任一种形式。我们可以这样编写程序：

while (getline(line, sizeof(line)) > 0) {
    if (sscanf(line, "%d %s %d", &day, monthname, &year) == 3)
        printf("valid: %s\n", line); /* 25 Dec 1988 form */
    else if (sscanf(line, "%d/%d/%d", &month, &day, &year) == 3)
        printf("valid: %s\n", line); /* mm/dd/yy form */
    else
        printf("invalid: %s\n", line); /* invalid form */
}

scanf 函数可以和其它输入函数混合使用。无论调用哪个输入函数，下一个输入函数的调用将从scanf没有读取的第一个字符处开始读取数据。

注意，scanf 和sscanf 函数的所有参数都必须是指针。最常见的错误是将输入语句写成下列形式：

scanf("%d", n);

正确的形式应该为：

scanf("%d", &n);

编译器在编译时一般检测不到这类错误。

5. 文件访问

到目前为止，我们讨论的例子都是从标准输入读取数据，并向标准输出输出数据。标准输入和标准输出是操作系统自动提供给程序访问的。

接下来，我们编写一个访问文件的程序，且它所访问的文件还没有连接到该程序。程序cat 可以用来说明该问题，它把一批命名文件串联后输出到标准输出上。cat 可用来在屏幕上打印文件，对于那些无法通过名字访问文件的程序来说。它还可以用作通用的输入收集器。例如，下列命令行：

cat x.c y.c

将在标准输出上打印文件x.c和y.c的内容。

问题在于，如何设计命名文件的读取过程呢？换句话说，如何将用户需要使用的文件的外部名同读取数据的语句关联起来。

方法其实很简单。在读写一个文件之前，必须通过库函数fopen打开该文件。fopen用类似于x.c或y.c这样的外部名与操作系统进行某些必要的连接和通信（我们不必关心这些细节），并返回一个随后可以用于文件读写操作的指针。

该指针称为文件指针，它指向一个包含文件信息的结构，这些信息包括：缓冲区的位置、缓冲区中当前字符的位置、文件的读或写状态、是否出错或是否已经到达文件结尾等等。用户不必关心这些细节，因为<stdio.h>中已经定义了一个包含这些信息的结构FILE。在程序中只需按照下列方式声明一个文件指针即可：

FILE *fp;
FILE *fopen(char *name, char *mode);

在本例中，fp是一个指向结构FILE的指针，并且，fopen函数返回一个指向结构FILE的指针。注意，FILE像int一样是一个类型名，而不是结构标记。它是通过typedef定义的（UNIX 系统中fopen的实现细节将在8.5 节中讨论）。

在程序中，可以这样调用fopen函数：

fp = fopen(name, mode);

fopen 的第一个参数是一个字符串，它包含文件名。第二个参数是访问模式，也是一个字符串，用于指定文件的使用方式。允许的模式包括：读（“r”）、写（“w”）及追加（“a”）。某些系统还区分文本文件和二进制文件，对后者的访问需要在模式字符串中增加字符“b”。

如果打开一个不存在的文件用于写或追加，该文件将被创建（如果可能的话）。当以写方式打开一个已存在的文件时，该文件原来的内容将被覆盖。但是，如果以追加方式打开一个文件，则该文件原来的内容将保留不变。读一个不存在的文件会导致错误，其它一些操作也可能导致错误，比如试图读取一个无读取权限的文件。如果发生错误，fopen将返回NULL。

（可以更进一步地定位错误的类型，具体方法请参见附录B.1节中关于错误处理函数的讨论。）

文件被打开后，就需要考虑采用哪种方法对文件进行读写。有多种方法可供考虑，其中，getc 和putc 函数最为简单。getc 从文件中返回下一个字符，它需要知道文件指针，以确定对哪个文件执行操作：

int getc(FILE *fp)

getc 函数返回fp 指向的输入流中的下一个字符。如果到达文件尾或出现错误，该函数将返回EOF，

putc是一个输出函数，如下所示：

int putc(int c, FILE *fp)

该函数将字符c写入到fp指向的文件中，并返回写入的字符。如果发生错误，则返回EOF。类似于getchar和putchar，getc和putc是宏而不是函数。

启动一个C 语言程序时，操作系统环境负责打开3 个文件，并将这3 个文件的指针提供给该程序。这3 个文件分别是标准输入、标准输出和标准错误，相应的文件指针分别为stdin、stdout 和stderr，它们在<stdio.h>中声明。在大多数环境中，stdin 指向键盘，而stdout 和stderr 指向显示器。我们从7.1 节的讨论中可以知道，stdin 和stdout 可以被重定向到文件或管道。

getchar和putchar函数可以通过getc、putc、stdin及stdout定义如下：

#define getchar() getc(stdin)
#define putchar(c) putc((c), stdout)

对于文件的格式化输入或输出，可以使用函数fscanf 和fprintf。它们与scanf 和
printf函数的区别仅仅在于它们的第一个参数是一个指向所要读写的文件的指针，第二个参数是格式串。如下所示：

int fscanf(FILE *fp, char *format, ...)
int fprintf(FILE *fp, char *format, ...)

掌握这些预备知识之后，我们现在就可以编写出将多个文件连接起来的cat 程序了。该程序的设计思路和其它许多程序类似。如果有命令行参数，参数将被解释为文件名，并按顺序逐个处理。如果没有参数，则处理标准输入。

#include <stdio.h>
/* cat: concatenate files, version 1 */
main(int argc, char *argv[])
{
    FILE *fp;
    void filecopy(FILE *, FILE *)
        if (argc == 1) /* no args; copy standard input */
            filecopy(stdin, stdout);
    else
        while(--argc > 0)
            if ((fp = fopen(*++argv, "r")) == NULL) {
                printf("cat: can't open %s\n, *argv);
                       return 1;
                       } else {
                           filecopy(fp, stdout);
                           fclose(fp);
                       }
                       return 0;
                       }
                       /* filecopy: copy file ifp to file ofp */
                       void filecopy(FILE *ifp, FILE *ofp)
                       {
                           int c;
                           while ((c = getc(ifp)) != EOF)
                               putc(c, ofp);
                       }

文件指针stdin与stdout都是FILE *类型的对象。但它们是常量，而非变量。因此不能对它们赋值。

函数

int fclose(FILE *fp)

执行和fopen 相反的操作，它断开由fopen 函数建立的文件指针和外部名之间的连接，并释放文件指针以供其它文件使用。因为大多数操作系统都限制了一个程序可以同时打开的文件数，所以，当文件指针不再需要时就应该释放，这是一个好的编程习惯，就像我们在cat程序中所做的那样。对输出文件执行fclose 还有另外一个原因：它将把缓冲区中由putc函数正在收集的输出写到文件中。当程序正常终止时，程序会自动为每个打开的文件调用fclose函数。（如果不需要使用stdin与stdout，可以把它们关闭掉。也可以通过库函数freopen重新指定它们。)

6. 错误处理–stderr和exit

cat 程序的错误处理功能并不完善。问题在于，如果因为某种原因而造成其中的一个文件无法访问，相应的诊断信息要在该连接的输出的末尾才能打印出来。当输出到屏幕时，这种处理方法尚可以接受，但如果输出到一个文件或通过管道输出到另一个程序时，就无法接受了。

为了更好地处理这种情况，另一个输出流以与stdin和stdout相同的方式分派给程序，即stderr。即使对标准输出进行了重定向，写到stderr中的输出通常也会显示在屏幕上。

下面我们改写cat程序，将其出错信息写到标准错误文件上。

#include <stdio.h>
/* cat: concatenate files, version 2 */
main(int argc, char *argv[])
{
    FILE *fp;
    void filecopy(FILE *, FILE *);
    char *prog = argv[0]; /* program name for errors */
    if (argc == 1 ) /* no args; copy standard input */
        filecopy(stdin, stdout);
    else
        while (--argc > 0)
            if ((fp = fopen(*++argv, "r")) == NULL) {
                fprintf(stderr, "%s: can't open %s\n",
                        prog, *argv);
                exit(1);
            } else {
                filecopy(fp, stdout);
                fclose(fp);
            }
    if (ferror(stdout)) {
        fprintf(stderr, "%s: error writing stdout\n", prog);
        exit(2);
    }
    exit(0);
}

该程序通过两种方式发出出错信息。首先，将fprintf 函数产生的诊断信息输出到
stderr上，因此诊断信息将会显示在屏幕上，而不是仅仅输出到管道或输出文件中。诊断信息中包含argv[0]中的程序名，因此，当该程序和其它程序一起运行时，可以识别错误的来源。

其次，程序使用了标准库函数exit，当该函数被调用时，它将终止调用程序的执行。任何调用该程序的进程都可以获取exit的参数值，因此，可通过另一个将该程序作为子进程的程序来测试该程序的执行是否成功。按照惯例，返回值0 表示一切正常，而非0 返回值通常表示出现了异常情况。exit为每个已打开的输出文件调用fclose函数，以将缓冲区中的所有输出写到相应的文件中。

在主程序main 中，语句return expr 等价于exit(expr)。但是，使用函数exit
有一个优点，它可以从其它函数中调用，并且可以用类似于第5 章中描述的模式查找程序查找这些调用。

如果流fp中出现错误，则函数ferror返回一个非0 值。

int ferror(FILE *fp)

尽管输出错误很少出现，但还是存在的（例如，当磁盘满时），因此，成熟的产品程序应该检查这种类型的错误。

函数 feof(FILE *)与ferror类似。如果指定的文件到达文件结尾，它将返回一个非
0 值。

int feof(FILE *fp)

在上面的小程序中，我们的目的是为了说明问题，因此并不太关心程序的退出状态，但对于任何重要的程序来说，都应该让程序返回有意义且有用的值。

7. 行输入和行输出–fgets和fputs

标准库提供了一个输入函数fgets，它和前面几章中用到的函数getline类似。

char *fgets(char *line, int maxline, FILE *fp)

fgets 函数从fp 指向的文件中读取下一个输入行（包括换行符），并将它存放在字符数组line中，它最多可读取maxline-1个字符。读取的行将以’\0’结尾保存到数组中。通常情况下，fgets返回line，但如果遇到了文件结尾或发生了错误，则返回NULL（我们编写的getline函数返回行的长度，这个值更有用，当它为0 时意味着已经到达了文件的结尾）。

输出函数 fputs将一个字符串（不需要包含换行符）写入到一个文件中：

int fputs(char *line, FILE *fp)

如果发生错误，该函数将返回EOF，否则返回一个非负值。

库函数gets和puts的功能与fgets和fputs函数类似，但它们是对stdin和stdout
进行操作。有一点我们需要注意，gets函数在读取字符串时将删除结尾的换行符（’\n’），而puts函数在写入字符串时将在结尾添加一个换行符。

下面的代码是标准库中fgets 和fputs 函数的代码，从中可以看出，这两个函数并没
有什么特别的地方。代码如下所示：

/* fgets: get at most n chars from iop */
char *fgets(char *s, int n, FILE *iop)
{
    register int c;
    register char *cs;
    cs = s;
    while (--n > 0 && (c = getc(iop)) != EOF)
        if ((*cs++ = c) == '\n')
            break;
    *cs = '\0';
    return (c == EOF && cs == s) ? NULL : s;
}
/* fputs: put string s on file iop */
int fputs(char *s, FILE *iop)
{
    int c;
    while (c = *s++)
        putc(c, iop);
    return ferror(iop) ? EOF : 0;
}

ANSI标准规定，ferror在发生错误时返回非0值，而fputs在发生错误时返回EOF，
其它情况返回一个非负值。

使用fgets函数很容易实现getline函数：

/* getline: read a line, return length */
int getline(char *line, int max)
{
    if (fgets(line, max, stdin) == NULL)
        return 0;
    else
        return strlen(line);
}

8. 其它函数

标准库提供了很多功能各异的函数。本节将对其中特别有用的函数做一个简要的概述。

更详细的信息以及其它许多没有介绍的函数请参见附录B。

8.1. 字符串操作函数

前面已经提到过字符串函数strlen、strcpy、strcat 和strcmp，它们都在头文件
<string.h>中定义。在下面的各个函数中，s与t为char *类型，c与n为int类型。

strcat(s, t) 将t指向的字符串连接到s指向的字符串的末尾
strncat(s, t, n) 将 t指向的字符串中前n个字符连接到s指向的字符串的末尾
strcmp(s, t) 根据s 指向的字符串小于（s<t）、等于（s==t）或大于（s>t）t
指向的字符串的不同情况，分别返回负整数、0或正整数
strncmp(s, t, n) 同 strcmp相同，但只在前n个字符中比较
strcpy(s, t) 将t指向的字符串复制到s指向的位置
strncpy(s, t, n) 将 t指向的字符串中前n个字符复制到s指向的位置
strlen(s) 返回s指向的字符串的长度
strchr(s, c) 在s指向的字符串中查找c，若找到，则返回指向它第一次出现的位
置的指针，否则返回NULL
strrchr(s, c) 在s指向的字符串中查找c，若找到，则返回指向它最后一次出现的
位置的指针，否则返回NULL

8.2. 字符类别测试和转换函数

头文件<ctype.h>中定义了一些用于字符测试和转换的函数。在下面各个函数中，c 是一个可表示为unsigned char类型或EOF的int 对象。该函数的返回值类型为int。

isalpha? 若c是字母，则返回一个非0 值，否则返回0
isupper? 若c是大写字母，则返回一个非0值，否则返回0
islower? 若c是小写字母，则返回一个非0值，否则返回0
isdigit? 若c是数字，则返回一个非0 值，否则返回0
isalnum? 若isalpha?或isdigit?，则返回一个非0值，否则返回0
isspace? 若c是空格、横向制表符、换行符、回车符，换页符或纵向制表符，
则返回一个非0 值
toupper? 返回c的大写形式
tolower? 返回c的小写形式

8.3. ungetc函数

标准库提供了一个称为ungetc的函数，它与第4 章中编写的函数ungetch相比功能更受限制。

int ungetc(int c, FILE *fp)

该函数将字符c写回到文件fp中。如果执行成功，则返回c，否则返回EOF。每个文件只能接收一个写回字符。ungetc函数可以和任何一个输入函数一起使用，比如scanf、getc或getchar。

8.4. 命令执行函数

函数 system(char* s)执行包含在字符申s 中的命令，然后继续执行当前程序。s 的
内容在很大程度上与所用的操作系统有关。下面来看一个UNIX 操作系统环境的小例子。语句

system("date");

将执行程序date，它在标准输出上打印当天的日期和时间。system函数返回一个整型的状态值，其值来自于执行的命令，并同具体系统有关。在UNIX 系统中，返回的状态是exit的返回值。

8.5. 存储管理函数

函数 malloc和calloc用于动态地分配存储块。函数malloc的声明如下：

void *malloc(size_t n)

当分配成功时，它返回一个指针，设指针指向n 字节长度的未初始化的存储空间，否则返回NULL。函数calloc的声明为

void *calloc(size_t n, size_t size)

当分配成功时，它返回一个指针，该指针指向的空闲空间足以容纳由n 个指定长度的对象组成的数组，否则返回NULL。该存储空间被初始化为0。

根据请求的对象类型，malloc或calloc函数返回的指针满足正确的对齐要求。下面的例子进行了类型转换：

int *ip;
ip = (int *) calloc(n, sizeof(int));

free§函数释放p 指向的存储空间，其中，p 是此前通过调用malloc 或calloc 函
数得到的指针。存储空间的释放顺序没有什么限制，但是，如果释放一个不是通过调用malloc或calloc函数得到的指针所指向的存储空间，将是一个很严重的错误。

使用已经释放的存储空间同样是错误的。下面所示的代码是一个很典型的错误代码段，它通过一个循环释放列表中的项目：

for (p = head; p != NULL; p = p->next) /* WRONG */
    free(p);

正确的处理方法是，在释放项目之前先将一切必要的信息保存起来，如下所示：

for (p = head; p != NULL; p = q) {
    q = p->next;
    free(p);
}

8.7 节给出了一个类似于malloc函数的存储分配程序的实现。该存储分配程序分配的存储块可以以任意顺序释放。

8.6. 数学函数

头文件<math.h>中声明了20 多个数学函数。下面介绍一些常用的数学函数，每个函数带有一个或两个double类型的参数，并返回一个double类型的值。

sin(x) x 的正弦函数，其中x 用弧度表示
cos(x) x 的余弦函数，其中x 用弧度表示
atan2(y, x) y/x 的反正切函数，其中，x 和y用弧度表示
exp(x) 指数函数ex
log(x) x 的自然对数（以e为底），其中，x>0
log10(x) x 的常用对数（以10为底），其中，x>0
pow(x, y) 计算xy的值
sqrt(x) x 的平方根（x≥0）
fabs(x) x 的绝对值

8.7. 随机数发生器函数

函数 rand()生成介于0 和RAND_MAX之间的伪随机整数序列。其中RAND_MAX是在头文件<stdlib.h>中定义的符号常量。下面是一种生成大于等于0 但小于1 的随机浮点数的方法：

#define frand() ((double) rand() / (RAND_MAX+1.0))

（如果所用的函数库中已经提供了一个生成浮点随机数的函数，那么它可能比上面这个函数具有更好的统计学特性。）

函数 srand(unsigned)设置rand函数的种子数。我们在2.7 节中给出了遵循标准的
rand和srand函数的可移植的实现。