常用C函数

一、C标准函数库

：诊断

中只定义了一个带参的宏assert，其定义形式如下：

void assert (int 表达式)

assert宏用于为程序增加诊断功能，它可以测试一个条件并可能使程序终止。在执行语句：

assert(表达式);

时，如果表达式为0，则在终端显示一条信息：

Assertion failed: 0, file 源文件名, line 行号 Abnormal program termination

然后调用abort终止程序的执行。 在中，带参宏assert是被定义为条件编译的，如果在源文件中定义了宏NDEBUG，则即使包含了头文件，assert宏也将被忽略。

：字符类别测试

在头文件中定义了一些测试字符的函数。在这些函数中，每个函数的参数都是整型int，而每个参数的值或者为EOF，或者为char类型的字符。中定义的标准函数列表如下：

中定义的函数

函数定义 int isalnum(int c) int isalpha(int c) int isascii(int c) int iscntrl(int c) int isdigit(int c) int isgraph(int c) int islower(int c) int isprint(int c) int ispunct(int c) int isspace(int c) int isupper(int c) int isxdigit(int c) int toupper(int c) int tolower(int c) 函数功能简介 检查字符是否是字母或数字 检查字符是否是字母 检查字符是否是ASCII码 检查字符是否是控制字符 检查字符是否是数字字符 检查字符是否是可打印字符 检查字符是否是小写字母 检查字符是否是可打印字符 检查字符是否是标点字符 检查字符是否是空格符 检查字符是否是大写字母 检查字符是否是十六进制数字字符 将小写字母转换为大写字母 将大写字母转换为小写字母

有关中定义的这些标准函数以及一些常用的非标准字符处理函数将在第十一章中进行详细地介绍。

：错误处理

中定义了两个常量，一个变量。 1、 EDOM

它表示数学领域错误的错误代码。 2、 ERANGE

它表示结果超出范围的错误代码。 3、 errno

这是一个变量，该值被设置成用来指出系统调用的错误类型。

：整型常量

在头文件中定义了一些表示整型大小的常量。下面给出这些常量的字符表示以及含义，见下表。

中定义的字符常量

字符常量 CHAR_BIT CHAR_MAX CHAR_MIN INT_MIN INT_MAX LONG_MAX LONG_MIN SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN UCHAR_MAX UINT_MAX ULONG_MAX USHRT_MAX 取值 8 255或127 0或-127 -32767 32767 2147483647 -2147483647 127 -127 32767 -32767 255 65535 4294967295 65535 含义 char类型的位数 char类型最大值 char类型最小值 int类型最小值 int类型最大值 long类型最大值 long类型最小值 signed char 类型最大值 signed char 类型最小值 short类型的最大值 short类型的最小值 unsigned char 类型最大值 unsigned int 类型最大值 unsigned long 类型最大值 unsigned short类型的最大值

：地域环境

在中，定义了7个常量，一个结构，2个函数。 1、常量的定义

LC_ALL：传递给setlocale的第一个参数，指定要更改该locale的哪个方面。 LC_COLLATE：strcoll和strxfrm的行为。 LC_CTYPE：字符处理函数。

LC_MONETARY：localeconv返回的货币信息。

LC_NUMERIC：localeconv返回的小数点和货币信息。 LC_TIME：strftime的行为。

以上扩展成具有唯一取值的整型常数表达式，可作为setlocale的第一个参数。 NULL：由实现环境定义的空指针。

2、struct lconv结构

该结构用于存储和表示当前locale的设置。其结构定义如下：

struct lconv {

char *decimal_point; char *thousands_sep; char *grouping;

char *int_curr_symbol; char *currency_symbol; char *mon_decimal_point; char *mon_thousands_sep; char *mon_grouping; char *positive_sign; char *negative_sign; char int_frac_digits; char frac_digits;

char p_cs_precedes; char p_sep_by_space; char n_cs_precedes; char n_sep_by_space; char p_sign_posn; char n_sign_posn; };

3、函数

struct Iconv *localeconv(void);

函数localeconv将一个struct Iconv类型的对象的数据成员设置成为按照当前地域环境的有关规则进行数量格式化后的相应值。

char *setlocale(int category,char * locale);

函数setlocale用于更改和查询程序的整个当前地域环境或部分设置。地域环境变量由参数category(上面定义的6个常量)和locale指定。

：数学函数

在中定义了一些数学函数和宏，用来实现不同种类的数学运算。下面给出中标准数学函数的函数定义及功能简介，见下表。

中定义的函数

函数定义 double exp(double x); double log(double x) double log10(double x); double pow(double x, double y); double sqrt(double x); double ceil(double x); double floor(double x); double fabs(double x); double ldexp(double x, int n); 函数功能简介 指数运算函数,求e的x次幂函数 对数函数ln(x) 对数函数log 指数函数(x的y次方) 计算平方根函数 向上舍入函数 向下舍入函数 求浮点数的绝对值 装载浮点数函数 double frexp(double x, int* exp); double modf(double x, double* ip); double fmod(double x, double y); double sin(double x); double cos(double x); double tan(double x); double asin(double x); double acos(double x); double atan(double x); double atan2(double y, double x); double sinh(double x); double cosh(double x); double tanh(double x);

分解浮点数函数 分解双精度数函数 求模函数 计算x的正弦值函数 计算x的余弦值函数 计算x的正切值函数 计算x的反正弦函数 计算x的反余弦函数 反正切函数1 反正切函数2 计算x的双曲正弦值 计算x的双曲余弦值 计算x的双曲正切值 在标准库中，还有一些与数学计算有关的函数定义在其他头文件中。

：非局部跳转

在头文件中定义了一种特别的函数调用和函数返回顺序的方式。这种方式不同于以往的函数调用和返回顺序，它允许程序流程立即从一个深层嵌套的函数中返回。

中定义了两个宏：

int setjmp(jmp_buf env); /*设置调转点*/

和

longjmp(jmp_buf jmpb, int retval); /*跳转*/

宏setjmp的功能是将当前程序的状态保存在结构env ，为调用宏longjmp设置一个跳转点。setjmp将当前信息保存在env中供longjmp使用。其中env是jmp_buf结构类型的，该结构定义为：

typedef struct { unsigned j_sp; unsigned j_ss; unsigned j_flag; unsigned j_cs; unsigned j_ip; unsigned j_bp; unsigned j_di; unsigned j_es; unsigned j_si; unsigned j_ds; } jmp_buf[1];

直接调用setjmp时，返回值为0，这一般用于初始化（设置跳转点时）。以后再调用longjmp宏时用env变量进行跳转。程序会自动跳转到setjmp宏的返回语句处，此时setjmp的返回值为非0，由longjmp的第二个参数指定。

下面通过例子来理解中定义的这两个宏。 例程9-1 非局部跳转演示。

#include

jmp_buf env; /*定义jmp_buf类型变量*/

int main(void) {

int value;

value = setjmp(env); /*调用setjmp，为longjmp设置跳转点*/ if (value != 0) {

printf(\ exit(value); /*退出程序*/

}

printf(\ ... \\n\

longjmp(env,1); /*跳转到setjmp语句处*/ return 0; }

本例程先应用setjmp宏为longjmp设置跳转点，当第一次调用setjmp时返回值为0，并将程序的当前状态（寄存器的相关状态）保存在结构变量env中。当程序执行到longjmp时，系统会根据setjmp保存下来的状态env跳转到setjmp语句处，并根据longjmp的第二个参数设置此时setjmp的返回值。

本例程的运行结果为：

Jump ...

Longjmp with value 1

一般地，宏setjmp和longjmp是成对使用的，这样程序流程可以从一个深层嵌套的函数中返回。

：信号

头文件中提供了一些处理程序运行期间引发的各种异常条件的功能，例如一些来自外部的中断信号等。

在中只定义了两个函数：

int signal(int sig, sigfun fname);

和

int raise(int sig);

signal函数的作用是设置某一信号的对应动作。其中参数sig用来指定哪一个信号被设置处理函数。在标准C 中支持的信号如下表。

标准C支持的信号

取值 SIGABRT SIGPPE SIGILL SIGINT SIGSEGV SIGTERM

说明 异常中止 算术运算错误 非法硬件指令 终端中断 无效的内存访问 中止信号 默认执行动作 中止程序 中止程序 中止程序 中止程序 中止程序 中止程序 使用的操作系统 UNIX DOS UNIX DOS UNIX DOS UNIX DOS UNIX DOS UNIX DOS 参数fname是一个指向函数的指针，当sig的信号发生时程序会自动中断转而执行fname

指向的函数。执行完毕再返回断点继续执行程序。系统提供了两个常量函数指针，可以作为函数的参数传递。它们分别是：

SIG_DEF：执行默认的系统第一的函数。

SIG_IGN：忽略此信号。

raise函数的作用是向正在执行的程序发送一个信号，从而使得当前进程产生一个中断而转向信号处理函数signal执行。其中参数sig为信号名称，它的取值范围同函数signal中的参数sig取值范围相同，见表9-6。

下面通过例子理解函数signal和raise。 例程9-2 signall和raise函数演示

#include #include void Print1(); void Print2(); int main()

{ signal(SIGINT,Print1);

printf(\getchar();

signal(SIGSEGV,Print2);

printf(\getchar();

raise(SIGSEGV); }

void Print1() {

printf(\}

void Print2() {

printf(\}

本例程首先通过用户终端输入Ctrl+c产生一个终端中断，然后应用signal函数调用中断处理函数Print1；再通过raise函数生成一个无效内存访问中断，并通过signal函数调用中断处理函数Print2。

本例程的运行结果为：

Please enter Ctr+c for interupt ^C

This is a SIGINT interupt!

Please enter any key for a interupt a

This is a SIGSEGV interupt!

：可变参数表

可变参数表中的宏是用来定义参数可变的函数的。在C语言中，有些库函数或者用户自定义的函数的参数是可变的，常用省略号“??”（例如库函数中的printf），定义这样的函数就要使用到中的宏。

1、va_list

用于保存宏va_start，va_arg以及va_end所需信息的数据类型。 2、中还定义了三个宏

void va_start(va_list ap, parmN); type va_arg(va_list ap,type);

void va_end (va_list ap);

va_start的作用是初始化ap，因此va_start要在所有其它的va_开头的宏前面最先使用(除了用va_list定义变量外)，后面的va_copy, va_arg, va_end都要使用到ap。在一对va_start和va_end之间不能再次使用va_start宏。其中，parmN 为\之前的最后一个参数。例如, printf函数定义为：printf(const char *format, ...); 那么在printf函数中的va_start使用之后, parmN 的值就等于*format。

va_arg的作用就是返回参数列表ap中的下一个具有type类型的参数, 每次调用va_arg都会修改ap的值, 这样才能连续不断地获取下一个type类型的参数。

va_end与va_start构成了一个scope，va_end标志着结束，va_end之后ap就无效了。

：公共定义

在头文件中，指定了标准库中的公共定义。其中主要包括以下内容： 1、NULL 空指针类型常量。

2、offset(type,member-designator)

它是扩展iz-t类型的一个整型常数表达式。它的值为从type定义的结构类型的开头到结构成员member-designator的偏移字节数。

3、ptrdiff_t

表示两指针之差的带符号整数类型。 4、size_t

表示由sizeof运算符计算出的结果类型，它是一个无符号整数类型。 5、wchar_t

它是一种整数类型，取值范围为在被支持的地域环境中最大扩展字符集的所有字符的各种代码，空字符代码值为0。

：输入输出

在头文件中定义了输入输出函数，类型和宏。这些函数、类型和宏几乎占到标准库的三分之一。

下面给出头文件中声明的函数以及功能简介，见下表。

中声明的函数

函数定义 FILE *fopen(char *filename, char *type) FILE *fropen(char *filename, char *type,FILE *fp) int fflush(FILE *stream) int fclose(FILE *stream) int remove(char *filename) int rename(char *oldname, char *newname) FILE *tmpfile(void) 函数功能简介 打开一个文件 打开一个文件，并将该文件关联到fp指定的流 清除一个流 关闭一个文件 删除一个文件 重命名文件 以二进制方式打开暂存文件 char *tmpnam(char *sptr) int setvbuf(FILE *stream, char *buf, int type, unsigned size) int printf(char *format...) int fprintf(FILE *stream, char *format[, argument,...]) int scanf(char *format[,argument,...]) int fscanf(FILE *stream, char *format[,argument...]) int fgetc(FILE *stream) char *fgets(char *string, int n, FILE *stream) int fputc(int ch, FILE *stream) int fputs(char *string, FILE *stream) int getc(FILE *stream) int getchar(void) char *gets(char *string) int putchar(int ch) int puts(char *string) int ungetc(char c, FILE *stream) int fread(void *ptr, int size, int nitems, FILE *stream) int fwrite(void *ptr, int size, int nitems, FILE *stream) int fseek(FILE *stream, long offset, int fromwhere) long ftell(FILE *stream) int rewind(FILE *stream) int fgetpos(FILE *stream) int fsetpos(FILE *stream, const fpos_t *pos) void clearerr(FILE *stream) int feof(FILE *stream) int ferror(FILE *stream) void perror(char *string) 创建一个唯一的文件名 把缓冲区与流相关 产生格式化输出的函数 传送格式化输出到一个流中 执行格式化输入 从一个流中执行格式化输入 从流中读取字符 从流中读取一字符串 送一个字符到一个流中 送一个字符到一个流中 从流中取字符 从stdin流中读字符 从流中取一字符串 在stdout上输出字符 送一字符串到流中 把一个字符退回到输入流中 从一个流中读数据 写内容到流中 重定位流上的文件指针 返回当前文件指针 将文件指针重新指向一个流的开头 取得当前文件的句柄 定位流上的文件指针 复位错误标志 检测流上的文件结束符 检测流上的错误 系统错误信息 在头文件中还定义了一些类型和宏。

：实用函数

在头文件中声明了一些实现数值转换，内存分配等类似功能的函数。下面给出头文件中声明的函数以及功能简介，见下表。

中声明的函数

函数定义 double atof(const char *s) int atoi(const char *s) long atol(const char *s) double strtod (const char*s,char **endp) long strtol(const char*s,char **endp,int base) unsinged long strtol(const char*s,char **endp,int base) int rand(void) void srand(unsigned int seed) void *calloc(size_t nelem, size_t elsize) void *malloc(unsigned size) void *realloc(void *ptr, unsigned newsize) void free(void *ptr) 函数功能简介 将字符串s转换为double类型 将字符串s转换为int类型 将字符串s转换为long类型 将字符串s前缀转换为double型 将字符串s前缀转换为long型 将字符串s前缀转换为unsinged long型 产生一个0~RAND_MAX之间的伪随机数 初始化随机数发生器 分配主存储器 内存分配函数 重新分配主存 释放已分配的块 void abort(void) void exit(int status) int atexit(atexit_t func) char *getenv(char *envvar) void *bsearch(const void *key, const void *base, size_t *nelem, size_t width, int(*fcmp)(const void *, const *)) void qsort(void *base, int nelem, int width, int (*fcmp)()) int abs(int i) long labs(long n) div_t div(int number, int denom) ldiv_t ldiv(long lnumer, long ldenom) 异常终止一个进程 终止应用程序 注册终止函数 从环境中取字符串 二分法搜索函数 使用快速排序例程进行排序 求整数的绝对值 取长整型绝对值 将两个整数相除, 返回商和余数 两个长整型数相除, 返回商和余数 有关上面列出的这些标准实用函数的功能、用法、例程等。 ：字符串函数

在头文件中定义了一些字符串函数。可以将它们分为两组。第一组函数名以str开头，主要进行字符串的操作；第二组函数名以mem开头，按照字符数组的方式操作对象。下面给出头文件中声明的函数以及功能简介，见下表。

中声明的函数

函数定义 char *strcpy(char *str1, char *str2) char *strncpy(char *d, char *s, int m) char *strcat(char *destin, char *source) char *strncat(char *d, char *s,int n) int strcmp(char *str1, char *str2) int strncmp(char *str1, char *str2, int m) char *strchr(char *str, char c) char *strrchr(char *str, char c) size_t strspn(char *str1, char *str2) size_t strcspn(char *str1, char *str2) char *strpbrk(char *str1, char *str2) char *strstr(char *str1, char *str2) size_t strlen(char *cs) char *strerror(int errnum) char *strtok(char *str1, char *str2) void *memcpy(void *d, void *s, unsigned n) 函数功能简介 串拷贝函数 串拷贝函数 字符串拼接函数 字符串拼接函数 串比较函数 串比较函数 在一个串中查找给定字符的第一个匹配之处 在串中查找指定字符的最后一个出现 在串中查找指定字符集的子集的第一次出现 在串中查找第一个给定字符集内容的段 在串中查找给定字符集中的字符 在串中查找指定字符串的第一次出现 求字符串的长度 返回指向错误信息字符串的指针 查找由在第二个串中指定的分界符分隔开的单词 从源s中拷贝n个字节到目标d中 void *memmove(void *d, void *s, unsigned n) 移动一块字节 void *memcmp(void *s1, void *s2, unsigned n ) 比较两个串s2和s1的前n个字节 void *memchr(void *s, char ch, unsigned n) 在数组的前n个字节中搜索字符 void *memset(void *s, char ch, unsigned n) 将s的前n个字符替换为字符ch

：日期与时间函数

在头文件中，声明了一些处理日期和时间的类型与函数。clock_t和time_t是两个表示时间值的算术类型。结构struct tm存储了一个日历时间的各个成分。结构tm的成员的意义及其正常的取值范围如下：

struct int int int int int int int int int };

tm {

tm_sec; /*从当前分钟开始经过的秒数(0,61)*/ tm_min; /*从当前小时开始经过的分钟数(0,59)*/ tm_hour; /*从午夜开始经过的小时数(0,23)*/ tm_mday; /*当月的天数(1,31)*/

tm_mon; /*从1月起经过的月数(0,11)*/ tm_year; /*从1900年起经过的年数*/

tm_wday; /*从本周星期天开始经过的天数(0,6)*/ tm_yday; /*从今年1月1日起经过的天数(0,356)*/ tm_isdst; /*夏令时标记*/

如果夏令时有效，夏令时标记tm_isdst值为正；若夏令时无效，tm_isdst值为0；如果得不到夏令时信息，tm_isdst值为负。

下面给出头文件中声明的时间函数，见下表。

中声明的时间函数

函数定义 clock_t clock(void) time_t time(time_t *tp) double difftime(time_t time2, time_t time1) time_t mktime(struct tm *tp) char *asctime(const struct tm *tblock) char *ctime(const time_t *time) struct tm *gmtime(const time_t *timer) struct tm *localtime(const time_t *timer) 函数功能简介 确定处理器时间函数 返回当前日历时间 计算两个时刻之间的时间差 将分段时间值转换为日历时间值 转换日期和时间为ASCII码 把日期和时间转换为字符串 把日期和时间转换为格林尼治标准时间(GMT) 把日期和时间转变为结构 size_t strftime(char *s,size_t smax,const char *fmt, 根据fmt的格式要求将*tp中的日期与时间转const struct tm *tp) 换为指定格式。

二、IO函数

clearerr：复位错误标志函数

函数原型：void clearerr(FILE *fp); 头文件：#include 是否是标准函数：是 函数功能：复位错误标志，即：使fp所指向的文件中的错误标志和文件结束标志置0。当输入输出函数对文件进行读写出错时，文件就会自动产生错误标志，这样会影响程序对文件的后续操作。clearerr函数就是要复位这些错误标志，也就是使fp所指向的文件的错误标志和文件结束标志置0，从而使文件恢复正常。

返回值：无

例程如下：复位错误标志演示。

#include int main(void) {

FILE *fp; char ch;

/* 以写的方式打开一个文件名为test.txt的文件 */ fp = fopen(\

/* 错误地从fp所指定的文件中读取一个字符，并打印它*/

ch = fgetc(fp); if (ferror(fp)) {

/* 如果此操作错误，就发布错误信息*/ printf(\ /*复位错误标志*/ clearerr(fp); }

/*关闭文件*/ fclose(fp); return 0; }

例程说明：

（1）首先程序以只写的方式打开一个文件名为”test.txt”的文件。这样，该文件就只能写而不能读了。

（2）程序企图应用fgetc函数从fp所指的文件中读出一个字符，这当然是违法的，因此文件自动产生错误标志。

（3）当用ferror函数检测出文件流存在错误时，就发布一条错误信息，并用clearerr函数清除fp指定的文件流所使用的错误标志，也就是使fp所指的文件的错误标志和文件结束标志置0。这样原先的错误就不会对文件的后续操作产生影响。

注意：ferror函数与clearerr函数应该配合使用。也就是说，通过ferror函数检测出文件有错误标志后要用clearerr函数复位错误标志。

feof：检测文件结束符函数

函数原型：int feof(FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：检测流上的文件结束符，即：检测文件是否结束。应用该函数可以判断一个文件是否到了结尾。在读取一个未知长度文件时，这个函数很有用。

返回值：遇到文件结束符返回非0，否则返回0。 例程如下：：检测文件结束标志演示。

#include

int main(void) {

FILE *stream;

/* 以只读方式打开test.txt文件 */ stream = fopen(\ /* 从文件中读取一个字符 */ fgetc(stream);

/*检测是否是EOF，即结束标志 */ if (feof(stream))

printf(\ /* 关闭该文件 */ fclose(stream); return 0; }

例程说明：

（1）首先程序打开一个名为test.txt的文件。

（2）应用fgetc函数从一个名为test.txt的文件中读取一个字符。 （3）判断它是否为文件结束标志EOF，如果是文件结束标志，就说明该文件已经结束，于是在屏幕上显示一条提示信息。如果不是文件的结束标志，就说明文件还未结束，信息不显示。

（4）最后关闭文件。

注意：在实际应用中，feof函数很重要，利用它程序员就可以很方便地判断当前的文件是否结束，从而进行不同的处理。例如，在从一个未知长度的文件中读取信息时，就可以利用feof函数判断什么时候该文件读完。

ferror：检测流上的错误函数

函数原型：int ferror(FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：检测流上的错误。即：检查文件在使用各种输入输出函数进行读写时是否出错。当输入输出函数对文件进行读写时出错，文件就会产生错误标志。应用这个函数，就可以检查出fp所指向的文件操作是否出错，也就是说是否有错误标志。

返回值：未出错返回值为0，否则返回非0，表示有错。 例程如下：应用ferror函数检查流上的错误。

#include int main(void) {

FILE *fp; char ch;

/* 以写的方式打开一个文件名为test.txt的文件 */ fp = fopen(\

/* 错误地从fp所指定的文件中读取一个字符，并打印它*/ ch = fgetc(fp); printf(\ if (ferror(fp)) {

/* 如果此操作错误，就发布错误信息*/ printf(\ /*复位错误标志*/ clearerr(fp); }

/*关闭文件*/ fclose(fp); return 0; }

例程说明：

（1）首先以只写的方式打开一个文件名为”test.txt”的文件。这样，该文件就只能写而不能读了。程序企图用fgetc函数从fp所指的文件中读出一个字符，这样就是非法操作，也就是说在用fgetc函数进行读取字符时出错了，因此文件产生错误标志。

（2）再用ferror函数来检测输入输出函数进行文件读写操作时是否出错，结果发现有错，因此函数返回一个非0整型数，并提示出错信息。

fflush：清除文件缓冲区函数

函数原型：int fflush(FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：清除一个流，即清除文件缓冲区，当文件以写方式打开时，将缓冲区内容写入文件。也就是说，对于ANSI C规定的是缓冲文件系统，函数fflush用于将缓冲区的内容输出到文件中去。

返回值：如果成功刷新，fflush返回0。指定的流没有缓冲区或者只读打开时也返回0值。返回EOF指出一个错误。

例程如下：第一种方式读写文件

#include #include #include #include

int main(void) {

FILE *stream1,*stream2; char test[20]=\char res[20];

/*以写的方式打开文件test.txt*/ stream1 = fopen(\ /*向文件写入字符串*/

fwrite(test,15,1,stream1);

/*以读的方式打开文件test.txt*/ stream2 = fopen(\ /*将文件内容读入缓冲区*/ if(fread(res,15,1,stream2)) printf(\else

printf(\fclose(stream1); fclose(stream2); getch(); return 0; }

例程如下：：第二种方式读写文件

#include #include #include #include

int main(void) {

FILE *stream1,*stream2; char test[20]=\char res[20];

/*以写的方式打开文件test.txt*/ stream1 = fopen(\ /*向文件写入字符串*/

fwrite(test,15,1,stream1); /*将缓冲区的内容写入文件*/ fflush(stream1);

/*以读的方式打开文件test.txt*/ stream2 = fopen(\ /*将文件内容读入缓冲区*/ if(fread(res,15,1,stream2)) printf(\else

printf(\fclose(stream1); fclose(stream2); getch(); return 0; }

例程说明：

例程如下：中定义了两个文件指针stream1和stream2。

（1）首先以写的方式打开文件test.txt，用指针stream1指向该文件，并向文件中写入字符串\。

（2）不关闭该文件，以读的方式打开文件test.txt，并用指针stream2指向该文件，试图将刚刚写入的字符串读入到内存缓冲区中。如果读入成功，打印出该字符串，否则报错。

实践证明，例程如下：的输出结果是在屏幕上显示错误信息Read error!。 例程如下：中定义了两个文件指针stream1和stream2。

（1）首先以写的方式打开文件test.txt，用指针stream1指向该文件，并向文件中写入字符串\。

（2）调用fflush函数将缓冲区的内容写入文件。

（3）不关闭该文件，以读的方式打开文件test.txt，并用指针stream2指向该文件，试图将刚刚写入的字符串读入到内存缓冲区中。如果读入成功，打印出该字符串，否则报错。

实践证明，例程如下：的输出结果是在屏幕上显示字符串\。

产生这样的效果原因在于：例程如下：中将文件打开后，指针stream1指向的是该文件的内存缓冲区，将字符串写入后也只是写到了文件的内存缓冲区中，而并没有写到磁盘上的文件中。而当以读的方式打开该文件时，该文件中的内容实际为空，也就是stream2指向的缓冲区中内容为空。因此读文件发生错误。而例程如下：中，在写完文件后调用函数fflush，将缓冲区的内容写到文件中，这样再以读的方式打开该文件时，文件中已经存有了字符串，因此可以正常读出。

注意：如果在写完文件后调用函数fclose关闭该文件，同样可以达到将缓冲区的内容写到文件中的目的，但是那样系统开销较大。

fgetc：从流中读取字符函数

函数原型：int fgetc(FILE *fp); 头文件：#include 是否是标准函数：是 函数功能：从流中读取字符，即从fp所指定的文件中取得下一个字符。这里需要注意，在每取完一个字符时fp会自动向下移动一个字节。这样编成时，程序员就不用再对fp控制了。这种功能在许多读写函数中都有体现。

返回值：返回所得到的字符，若读入错误。返回EOF。 例程如下：应用fgetc函数从文件中自动读取字符。

#include

#include #include int main(void) {

FILE *fp;

char string[] = \ char ch;

/* 以读写方式打开一个名为test.txt的文件 */ fp = fopen(\

/* 向文件中写入字符串string */ fwrite(string, strlen(string), 1, fp); /* 将fp指针指向文件首 */ fseek(fp, 0, SEEK_SET); do {

/* 从文件中读一个字符 */ ch = fgetc(fp);

/* 显示该字符 */ putch(ch);

} while (ch != EOF); fclose(fp); return 0; }

例程说明：

（1）首先程序先以读写方式打开一个名为test.txt的文件，并向该文件中写入一个字符串。

（2）再应用fseek函数将文件指针fp定位在文件的开头，再循环地将字符逐一读出。这里每读出一个字符，指针fp会自动地向后移一个字节，直至读到文件尾，即EOF标志，循环才停止。因为fgetc函数的返回值为得到的字符，所以用一个字符型变量ch 来接受读出的字符。

（3）最后的运行结果是在屏幕上打印出This is a test字符串。

fgetpos：取得当前文件的句柄函数

函数原型：int fgetpos( FILE *stream, fpos_t *pos ); 头文件：#include 是否是标准函数：是 函数功能：取得当前文件的指针所指的位置，并把该指针所指的位置数存放到pos所指的对象中。pos值以内部格式存储,仅由fgetpos和fsetpos使用。其中fsetpos的功能与fgetpos相反，为了详细介绍，将在后节给与说明。

返回值：成功返回0，失败返回非0，并设置errno。

例程如下：应用fgetpos函数取得当前文件的指针所指的位置。

#include #include int main(void) {

FILE *fp;

char string[] = \ fpos_t pos;

/* 以读写方式打开一个名为test.txt的文件 */

fp = fopen(\ /* 将字符串写入文件 */

fwrite(string, strlen(string), 1, fp);

/* 取得指针位置并存入&pos所指向的对象 */ fgetpos(fp, &pos);

printf(\ /*重设文件指针的位置*/

fseek(fp,3,0);

/* 再次取得指针位置并存入&pos所指向的对象 */ fgetpos(fp, &pos);

printf(\fclose(fp); return 0; }

例程说明：

（1）首先，程序以读写方式打开一个名为test.txt的文件，并把字符串\写入文件。注意：字符串共14个字节，地址为0~13。用fwrite函数写入后，文件指针自动指向文件最后一个字节的下一个位置。即这时的fp的值应该是14。

（2）再用fgetpos函数取得指针位置并存入&pos所指向的对象，此时， pos中的内容为14。然后在屏幕上显示出The file pointer is at byte 14。 （3）再用fseek函数重设文件指针的位置，让fp的值为3，即指向文件中第4个字节。 再次取得指针位置并存入&pos所指向的对象。然后在屏幕上显示出The file pointer is at byte 3。

fgets：从流中读取字符串函数

函数原型：char *fgets(char *string, int n, FILE *fp); 头文件：#include 是否是标准函数：是 函数功能：从fp所指的文件中读取一个长度为(n-1)的字符串，并将该字符串存入以string为起始地址的缓冲区中。fgets函数有三个参数，其中string为缓冲区首地址，n规定了要读取的最大长度，fp为文件指针。

返回值：返回地址string，若遇到文件结束符或出错，返回NULL。用feof 或ferror判断是否出错。

例程如下：用fgets函数从文件中读取字符串。

#include #include int main(void) {

FILE *fp;

char string[] = \ char str[20];

/* 以读写的方式打开一个名为test.txt的文件 */ fp = fopen(\ /* 将字符串写入文件 */ fwrite(string, strlen(string), 1, fp); /* 文件指针定位在文件开头*/

fseek(fp, 0, SEEK_SET);

/* 从文件中读一个长为strlen(string)的字符串 */ fgets(str, strlen(string)+1, fp);

/* 显示该字符串 */ printf(\fclose(fp); return 0; }

例程说明：

（1）首先，以读写的方式打开一个名为test.txt的文件，并将字符串写入文件。 应用fseek函数将文件指针定位在文件开头。

（2）从文件中读一个长为strlen(string)的字符串，这里应注意第二个参数若为n，则表示从fp所指的文件中读取一个长度为(n-1)的字符串。因此，这里的参数为strlen(string)+1，表示读取一个长度为strlen(string)的字符串。把字符串读到以str为首地址的数组中。 （3）最后显示该字符串。

fopen、fclose：文件的打开与关闭函数

函数原型：FILE *fopen(char *filename, char *type);

int fclose(FILE *fp);

头文件：#include 是否是标准函数：是

函数功能：函数fopen：打开一个流，即：打开一个文件。该函数有两个参数，filename是需要打开文件的文件名，type是打开文件的方式。函数fclose：关闭一个流，即：关闭一个文件，并释放文件缓冲区。fclose函数与fopen函数是相对的两个函数。fclose函数的参数是指向文件的指针，应用该函数用以在程序结束之前关闭文件，并释放文件缓冲区。这样可以保证文件的数据不流失。

在这里，特别列出所有的文件打开方式，以供大家参考。如下表所示。

文件的打开方式

文件使用方式 意义 r 只读打开一个文本文件，只允许读数据 w 只写打开或建立一个文本文件，只允许写数据 a rb wb ab r+ w+ a+ rb+ wb+ ab+ 追加打开一个文本文件，并在文件末尾写数据 只读打开一个二进制文件，只允许读数据 只写打开或建立一个二进制文件，只允许写数据 追加打开一个二进制文件，并在文件末尾写数据 读写打开一个文本文件，允许读和写 读写打开或建立一个文本文件，允许读写 读写打开一个文本文件，允许读，或在文件末追加数据 读写打开一个二进制文件，允许读和写 读写打开或建立一个二进制文件，允许读和写 读写打开一个二进制文件，允许读，或在文件末追加数据 返回值：fopen：FILE类型，如果打开的文件存在，返回指向该文件的指针；如果打开的文件不存在，则在指定的目录下建立该文件打开，并返回指向该文件的指针。fclose：整型，有错返回非0，否则返回0。

例程如下：打开并输出一个文件，然后关闭。

#include #include int main(void) {

FILE *fp;

char buf[11] = \

/* 以写方式打开文件名为test.txt的文件 */ fp = fopen(\

/*把字符串写入文件中*/ fwrite(&buf, strlen(buf), 1, fp); /* 关闭文件 */ fclose(fp); return 0; }

例程说明：

（1）首先开辟一个11个字节大小的缓冲区buf，也就是数组，但预先只能存入10个字符。这是因为C语言中规定数组存放字符串时，最后一个字节要以’/0’结尾，作为结束标志，并由系统自动在字符串末尾添加’/0’标志。因此，11个字节大小的缓冲区只存放一个长10个字节的字符串。

（2）用fopen函数以写的方式打开一个名为test.txt的文件并将字符串写入文件。 调用fclose函数关闭该文件。

（3）fclose函数与fopen函数正好相对，其作用是关闭一个文件。当使用fopen函数打开一个文件时，会返回一个指向该文件的指针。在该例程中这个指针被赋值给fp，也就是说fp指向了test.txt这个文件。而当调用fclose函数关闭该文件，即fclose(fp)时，fp就不再指向该文件了，相应的文件缓冲区也被释放。

注意：用户在编写程序时应该养成及时关闭文件的习惯，如果不及时关闭文件，文件数据有可能会丢失。

fprintf：格式化输出函数

函数原型：int fprintf(FILE *fp, char *format[, argument,...]); 头文件：#include 是否是标准函数：是

函数功能：把argument的值以format所指定的格式输出到fp指向的文件中。这个函数理解起来和printf类似，在一般的使用中，第二个参数可以是一个字符串的头指针，也可以就是一个字符串。例如：fprintf(fp, \，意思就是把字符串Cannot open this file!!输出到文件fp中去。该函数一般用作终端的出错提示或是在磁盘中生成错误报告。

返回值：如果正确返回实际输出字符数，若错误则返回一个负数。 例程如下用fprintf函数向终端发出出错提示。

#include int main(void) {

FILE *fp;

/*以只读方式打开名为test.txt的文件*/

if ((fp = fopen(\ == NULL) {

fprintf(stderr, \

return 1; /*若该文件不能打开，在屏幕上显示出错提示*/ }

/*若该文件能够打开，在屏幕上显示正确提示*/ fprintf(stderr,\return 0;

}

例程说明：

（1）首先，以只读方式打开名为test.txt的文件，如果文件不能打开，这返回NULL。 （2）若该文件不能打开，在屏幕上显示出错提示。 （3）若该文件能够打开，在屏幕上显示正确提示。

注意：该函数中第一个参数是stderr，这是C语言中标准出错输出指针，它指向标准的出错输出文件，也就是显示器。因为，在操作系统中，I/O设备都是用文件进行管理的，因此设备都配有相应的控制文件。在C语言中，有三个文件与终端相联系，因此系统定义了三个文件指针。见下表：

设备文件 标准输入 标准输出 文件指针 stdin stdout 标准文件指针

stderr 标准出错输出

在系统运行时，程序自动打开这三个标准文件。

本例程的运行结果为： （1）如果不能打开文件：

Cannot open this file!!

（2）如果可以打开文件：

Have open this file!!

例程如下用fprintf函数在磁盘中生成错误报告。

#include int main(void) {

FILE *fp1,*fp2;

/*以只读方式打开名为test.txt的文件*/ if ((fp1 = fopen(\ == NULL) { /*若文件打不开，则生成错误报告*/ fp2=fopen(\ fprintf(fp2, \return 1; } return 0; }

例程说明：

（1）首先，以只读方式打开名为test.txt的文件，如果文件不能打开，这返回NULL。 （2）若该文件不能打开，则以写的方式打开一个名为report.txt的文件，并按照格式要求向文件中写入字符串\，即生成了一个错误报告。

注意：这里函数fprintf的第一个参数为文件指针，是用户自定义的，与上一例程的系统定义的文件指针stderr不同。fprintf函数与printf函数的使用类似，其实printf函数是fprintf函数的一个特例，printf函数只能向标准输出文件（显示器）输出数据，而fprintf函数也可以向一般用户定义的文件输出数据。

fputc：向流中输出字符函数

函数原型：int fputc(char ch, FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：将字符ch输出到fp指向的文件中。该函数与前边提到的fgetc是相对的，第一个参数ch是字符型变量，函数将该变量中的字符输出到fp指向的文件中。

返回值：成功返回该字符，否则返回非0。 例程如下应用fputc向文件输出字符。

#include int main(void) { /*初始化字符数组str */

char str[] = \int i = 0; /*将数组中的字符循环输出至屏幕*/ while (str[i]) {

fputc(str[i], stdout); i++; } return 0; }

例程说明：

（1）首先初始化字符数组str。这里应当知道，在C语言中初始化数组，系统会自动在数组最后添加\，以表示该字符串结束。

（2）将数组中的字符循环输出至屏幕。这里注意两点：

? 该循环以\作为结束标志，即循环碰到\时结束。

? 函数fputc的第二个参数是stdout，前面已讲过它代表标准输出文件指针，这

样就是在屏幕上显示该字串。

本例程的运行结果为：

This is a test

fputs：向流中输出字符串函数

函数原型：int fputs(char *string, FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：将string所指的字符串输出到fp指向的文件中。该函数与fgets相对，第一个参数为字符串指针。与fgets函数不同的是，fputs函数没有字符串长度的限制，只是将string指向的字符串输出到文件中。

返回值：成功返回0，否则返回非0。

例程如下应用fputs函数向文件中输出字符串。

#include int main(void) {

FILE *fp;

char str[]=\

/*以写的方式打开名为test.txt的文件*/ fp=fopen(\ /*将字符串写入文件*/ fputs(str,fp); fclose(fp); return 0; }

例程说明：

（1）首先用字符数组str存储一个字符串，并以写的方式打开名为test.txt的文件。 （2）再用fputs函数将该字符串输出到test.txt的文件中。

fread：从流中读取字符串函数

函数原型：int fread(void *buf, int size, int count, FILE *fp); 头文件：#include 是否是标准函数：是 函数功能：从fp指向的文件中读取长度为size 的count个数据项，并将它输入到以buf为首地址的缓冲区中。此时，文件指针fp会自动增加实际读入数据的字节数，即fp指向最后读入字符的下一个字符位置。

返回值：返回实际读入数据项的个数，即count值。若遇到错误或文件结束返回0。 例程如下应用fread函数从文件中读取数据到缓冲区。

#include #include int main(void) {

FILE *fp;

char str[] = \char buf[20];

if ((fp = fopen(\ == NULL) {

fprintf(stderr,

\return 1; }

/* 向文件中写入字符串数组中的数据 */ fwrite(str, strlen(str), 1, fp);

/* 将文件指针定位到文件开头 */ fseek(fp, SEEK_SET, 0);

/* 把文件中的数据读出并显示 */ fread(buf, strlen(str), 1, fp); printf(\ fclose(fp); return 0; }

例程说明： （1）程序首先以读写方式打开名为test.txt的文件。这里有一个判断，若打开文件失败，则在屏幕上显示出错信息。

（2）应用fwrite函数向文件写入数据。有关fwrite函数后面做详细介绍。 （3）应用fseek函数将文件指针定位到文件开头。

（4）应用fread函数把文件中的数据读入内存。这里读取一个长度为strlen(str)的字符串，并将该字符串存入以buf为首地址的内存缓冲区中。 （5）显示该字符串。

freopen：替换文件中数据流函数

函数原型：FILE *freopen(char *filename, char *type, FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：关闭fp所指向的文件，并将该文件中的数据流替换到filename所指向的文件中去。该函数共三个参数：第一个参数filename是文件流将要替换到的文件名路径；第二个参数type是文件打开的方式，它与fopen中的文件打开方式类似；第三个参数fp是要被替换的文件指针。

返回值：返回一个指向新文件的指针，即指向filename文件的指针。若出错，则返回NULL。

例程如下关闭一个终端，并将数据流替换至一个新文件中。

#include int main(void) {

FILE *Nfp;

/* 替换标准输出文件上的数据流到新文件test.txt */ if (Nfp=freopen(\ == NULL)

fprintf(stderr, \

/* 标准输出文件上的数据流将会被替换到新文件中 */ printf(\

/* 关闭标准输出文件 */ fclose(stdout);

/*关闭新生成的文件*/ fclose(Nfp); return 0; }

例程说明：

（1）首先，程序以写的方式打开名为test.txt的文件，将标准输出文件上的数据流\will go into a file.\替换到新生成的文件test.txt中。freopen函数返回一个指向新文件的指针，即指向文件test.txt的指针，并将它存放到Nfp中。 （2）然后关闭标准输出文件，fclose(stdout)。 （3）最后关闭新生成的文件fclose(Nfp)。

（4）本程序的执行结果是在当前目录下生成一个文件test.txt，并将原终端的数据流\重新写入test.txt文件中。

fscanf：格式化输入函数

函数原型：int fscanf(FILE *fp, char *format[,argument...]);

头文件：#include 是否是标准函数：是 函数功能：从fp所指向的文件中按format给定的格式读取数据到argument所指向的内存单元。其中argument是指针，指针类型要与输入的格式format相一致。例如：fscanf(stdin, \；&i是整型的指针，输入的格式format也要为整型，即\。

返回值：返回已输入的数据个数。若错误或文件结束返回EOF。 例程如下应用fscanf函数从终端向内存输入数据。

#include #include int main(void) {

char ch;

printf(\

/* 从标准输入文件中读取一个字符，并送至ch */ if (fscanf(stdin, \

printf(\ was: %c\\n\else {

/*出错提示*/

fprintf(stderr, \exit(1); } return 0; }

例程说明：

（1）首先，程序提示用户从键盘输入一个字符。这时，标准输入文件指针stdin指向该字符。 （2）调用fscanf函数从标准输入文件中读取一个字符，并送至ch。这里应该注意两点：

? fscanf函数的第一个参数不是用户定义的文件指针，而是系统定义的标准输入

文件指针stdin。但用法与用户定义的文件指针类似。 ? &ch是指向字符型数据的指针，因此，输入的格式format也要为字符型\，

它们必须保持一致。

（3）该函数的使用与scanf类似。其实，scanf函数是fscanf函数的一个特例，它只能从标准输入文件（键盘终端）中输入数据。而fscanf函数则也可以从一般用户定义的文件中输入数据。

fseek：文件指针定位函数

函数原型：int fseek(FILE *fp, long offset, int base); 头文件：#include 是否是标准函数：是 函数功能：重定位流上的文件指针，即将fp指向的文件的位置指针移向以base为基准，以offset为偏移量的位置。该函数有三个参数：fp为文件指针，offset为偏移量，即位移offset个字节，base为指针移动的基准，即起始点。其中，基准base用0、1或2表示。在ANSI C标准指定的名字如下表

ANSI C标准指定的起始点名字

起始点 文件当前位置 名字 SEEK_CUR 数字代码 1 文件开始位置 文件末尾位置 SEEK_SET SEEK_END 0 2

偏移量用长整型数表示。ANSI C标准规定，在数的末尾加L就表示长整型数。该函数在随机读取较长的顺序文件时是很有用的。

返回值：成功返回0，否则返回非0。 例程如下文件指针的定位演示。

#include void main( void ) {

FILE *fp; char line[81]; int result;

/*以读写的方式打开打开名为test.txt的文件*/ fp = fopen( \if( fp == NULL )

printf( \！\\n\else {

/*按照规定格式将字符串写入文件*/

fprintf( fp, \

\ /*将文件指针定位到离文件头23个字节处*/ result = fseek( fp, 23L, SEEK_SET); if( result )

perror( \else {

printf( \ /*从fp指向的文件中读取字符串*/ fgets( line, 80, fp );

/*显示读取的字符串*/ printf( \ } fclose(fp); } }

例程说明：

（1）首先，程序以读写的方式打开打开名为test.txt的文件。 （2）然后，应用fprintf函数按照规定格式将字符串\'test.txt'.\\n\写入文件。 （3）再将文件指针定位到离文件头23个字节处，即将文件指针fp定位在字符串\the file 'test.txt'.\\n\的开头。

（4）然后，应用fgets函数从fp指向的文件中读取字符串，并显示在屏幕上。 本程序的运行结果为在屏幕上显示出以下字符串：

File pointer is set to middle of first line. This is the file 'test.txt'.

fsetpos：定位流上的文件指针函数

函数原型：int fsetpos(FILE *fp, const fpos_t *pos); 头文件：#include 是否是标准函数：是

函数功能：将文件指针定位在pos指定的位置上。该函数的功能与前面提到的fgetpos相反，是将文件指针fp按照pos指定的位置在文件中定位。pos值以内部格式存储,仅由fgetpos和fsetpos使用。

返回值：成功返回0，否则返回非0。 例程如下应用fsetpos函数定位文件指针。

#include void main( void ) {

FILE *fp; fpos_t pos;

char buffer[50];

/*以只读方式打开名为test.txt的文件*/ if( (fp = fopen( \printf( \else {

/*设置pos值*/

pos = 10;

/*应用fsetpos函数将文件指针fp按照 pos指定的位置在文件中定位*/

if( fsetpos( fp, &pos ) != 0 ) perror( \else

{

/*从新定位的文件指针开始读取16个字符到buffer缓冲区*/ fread( buffer, sizeof( char ), 16, fp ); /*显示结果*/

printf( \ } } fclose( fp ); }

例程说明：

（1）首先，程序以只读方式打开名为test.txt的文件。在这里，test.txt文件中已存入字符串This is a test for testing the function of fsetpos.

（2）将pos设置为10。应用fsetpos函数将文件指针fp按照pos指定的位置在文件中定位。这样文件指针fp指向字符串中test的字母t。 （3）再从新定位的文件指针开始读取16个字符到buffer缓冲区，也就是说读取字符串\到缓冲区buffer。

（4）最后显示结果：16 bytes at byte 10: test for testing 。

ftell：返回当前文件指针位置函数

函数原型：long ftell(FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：返回当前文件指针的位置。这个位置是指当前文件指针相对于文件开头的位移量。

返回值：返回文件指针的位置，若出错则返回–1L。 例程如下应用ftell返回文件指针位置。

#include int main(void) {

FILE *fp;

fp = fopen(\

/*按照格式要求将字符串写入文件*/ fprintf(fp, \

/*读出文件指针fp的位置*/

printf(\fclose(fp); return 0; }

例程说明：

（1）首先以写方式打开名为test.txt的文件，按照格式要求将字符串写入文件。注意：字符串共14个字符，地址为0~13。调用fprintf函数后，文件指针自动移到读入的最后一个字符的下一个位置，本例中就是文件的结束符，它的地址是14。 （2）应用ftell函数读出文件指针fp的位置。

注意：本题中ftell函数的返回值实际上就是该文件的长度。在实际的应用中，函数ftell常用来计算文件的长度。

fwrite：向文件写入数据函数

函数原型：int fwrite(void *buf, int size, int count, FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：将buf所指向的count*size个字节的数据输出到文件指针fp所指向的文件中去。该函数与fread相对，输出数据后，文件指针fp自动指向输出的最后一个字符的下一个位置。该函数常用于分批将数据块输出到文件中。

返回值：返回实际写入文件数据项个数。

例程如下应用fwrite函数向文件中写入数据块。

#include struct exp_struct { int i; char ch; };

int main(void) {

FILE *fp;

struct exp_struct s;

/*以写的方式打开名为test.txt的文件*/ if ((fp = fopen(\ {

fprintf(stderr, \return 1; }

/*向结构体中的成员赋值*/

s.i = 0; s.ch = 'A';

/* 将一个结构体数据块写入文件 */ fwrite(&s, sizeof(s), 1, fp); fclose(fp); return 0; }

例程说明：

（1）程序先声明一个结构体类型struct exp_struct，这样一个结构体变量就是一个小数据块。

（2）再以写的方式打开名为test.txt的文件。 （3）然后向结构体中的成员变量赋值，并将赋值好的数据块应用fwrite函数写入fp 所指向的文件中。这里参数sizeof(s)是该结构体变量的大小，1指只写入文件1个数据块。 （4）最后关闭该文件。

getc：从流中读取字符函数

函数原型：int getc(FILE *fp); 头文件：#include 是否是标准函数：是 函数功能：从fp所指向的文件中读取一个字符。该函数与前面所讲到的fgetc作用类似。读取字符后，文件指针fp自动指向下一个字符。

返回值：返回所读的字符，若文件结束或出错返回EOF。 例程如下应用getc函数从标准输入文件中读取一个字符。

#include int main(void) {

char ch;

printf(\

/* 从标准输入文件中读取一个字符 */ ch = getc(stdin); /*显示该字符*/

printf(\return 0; }

例程说明：

本程序是从标准输入文件（键盘）中读取一个字符，存入变量ch，并显示在屏幕上。 例程如下应用getc函数从一般文件中读取字符。

#include void main( void ) {

FILE *fp;

char ch;

/*以写的方式打开名为test.txt的文件*/ fp=fopen(\ /*写入字符串*/

fprintf(fp,\fclose(fp);

/*再以读的方式打开名为test.txt的文件*/ fp=fopen(\

/*将文件指针指向文件开头*/

fseek(fp,0L,SEEK_SET);

/*应用getc函数从文件中循环读取字符并显示出来*/ while(feof(fp)==0) {

ch=getc(fp); printf(\ }

fclose(fp); return 0; }

例程说明： （1）首先以写的方式打开名为test.txt的文件，并将字符串\写入字符串。 （2）再以读的方式打开名为test.txt的文件，并将文件指针指向文件开头。

（3）最后，应用getc函数从文件中循环读取字符，直到文件结束为止，并将读取的字符显示到终端屏幕。

注意：本例程与上例不同，上例是从标准输入文件（键盘）中读取一个字符，本例是从一般文件中读取字符，关键在于函数的参数不同。

gets：从标准输入文件中读取字符串函数

函数原型：char *gets(char *buf); 头文件：#include 是否是标准函数：是

函数功能：从标准输入文件stdin（键盘）中读取一个字符串，并把该字符串存入以buf为首地址的缓冲区中。该函数与fgets类似，但它只能从标准输入文件stdin中读取字符串，而且没有长度限制。

返回值：返回其参数，即缓冲区指针buf，若出错则返回空NULL。 例程如下应用gets函数从键盘读取字符串。

#include int main(void) {

char string[30];

printf(\

/*从终端输入字符串，注意不要超过30个字符*/ gets(string);

/*显示该字符串*/

printf(\return 0; }

例程说明：

（1）首先，程序开辟一个可容纳30个字符的字符串数组空间，并在屏幕上提示用户输入一个字符串。

（2）应用gets函数接收键盘输入的字符串，并把它存储到以string为首地址的缓冲区中。

（3）最后，将以string为首地址的缓冲区中的内容显示出来，即在屏幕上显示输入的字符串。

perror：打印系统错误信息函数

函数原型：void perror(char *string); 头文件：#include 是否是标准函数：是

函数功能：将错误信息输出到标准出错输出stderr。该函数的参数是字符串指针，指向错误信息字符串。也可以就是一个字符串，直接在参数中输入要显示的错误信息。但要注意，完整的错误信息不仅包括用户在参数中自己定义的字符串，还包括一个冒号，系统报错信息，和一个换行符。该函数主要用作向终端进行错误提示。

返回值：无。

例程如下应用perror函数显示错误信息。

#include int main(void) {

FILE *fp;

/*企图以读的方式打开文件test.txt*/ fp = fopen(\if (fp==NULL)

/*该文件不存在，在终端显示错误信息*/ perror(\ return 0; }

例程说明：

（1）首先程序企图以读的方式打开文件test.txt，但在这里该文件并不存在。 （2）然后，利用函数perror在终端显示错误信息\file or directory\。

具体的运行结果格式如下：

Unable to open file for reading: No such file or directory

注意：完整的错误信息包括：用户自定义字符串，冒号，系统报错信息，换行符。

printf：产生格式化输出的函数

函数原型：int printf( const char *format [, argument]... ); 头文件：#include 是否是标准函数：是

函数功能：按format指向的格式字符串所规定的格式，将输出表列argument的值输出到标准输出设备。该函数与fprintf类似，但只能将argument的值输出到标准输出设备stdout,即显示器屏幕，而不能输出到用户自定义的文件中。

返回值：输出字符的个数，若出错则返回一个负数。 例程如下应用printf函数输出字符串。

#include #include int main(void) {

int a=1; char ch='r';

char str[]=\printf(\printf(\

printf(\printf(\return 0; }

例程说明：

（1）首先在标准输出设备stdout,即显示器屏幕上打印出\。 （2）再打印出字符串str中的内容：\。 （3）再打印出整型数a：The integer is 1。 （4）再打印出字符ch：The character is r。

putc：向指定流中输出字符函数

函数原型：int putc(int ch, FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：向指定的文件输出一个字符。该函数有两个参数，ch是用户指定的字符，fp是文件指针。函数将字符ch输出到fp指定的文件中。

返回值：返回输出的字符ch，若出错则返回EOF。 例程如下应用putc函数向标准输出文件输出字符。

#include int main(void) {

char str[] = \int i = 0; while (str[i]){

putc(str[i], stdout); i++; } return 0; }

例程说明：

（1）首先将字符串\存入字符串数组str中。

（2）循环地将数组str中的内容输出到标准输出文件（显示器）上。 例程如下应用putc函数向用户自定义文件输出字符。

#include int main(void) {

FILE *fp; int i = 0;

char str[]=\fp=fopen(\while (str[i]){ putc(str[i], fp); i++; } fclose(fp); return 0; }

例程说明：

（1）首先将字符串\存入字符串数组str中。

（2）以写的方式打开一个名为\文件，并利用函数putc将数组str中的内容输出到文件\中。 （3）关闭文件。

注意：该函数既可以向标准输出文件输出字符，又可以向用户自定义文件输出字符。而且，每当向文件输出一个字符时，文件指针就会自动向后移一个字节。

putchar：向标准输出文件上输出字符

函数原型：int putchar(char ch); 头文件：#include 是否是标准函数：是

函数功能：将字符串ch输出到标准输出文件stdout上。也就是说将字符串ch输出到显示器屏幕上。

返回值：返回输出的字符ch，若出错，则返回EOF。 例程如下应用putchar函数在屏幕上显示字符。

#include int main() {

char str[]=\int i=0;

while(str[i]){ putchar(str[i]); i++; } }

例程说明：

（1）首先将字符串\存入字符串数组str中。

（2）应用putchar函数，循环地将字符串输出到标准输出文件（终端屏幕）上。 注意：该函数与putc函数不同，它只能向标准输出文件，也就是终端屏幕上输出字符。而putc函数既可以向标准输出文件上输出字符，又可以向一般用户自定义文件上输出字符。

puts：将字符串输出到终端函数

函数原型：int puts(char *string); 头文件：#include

是否是标准函数：是

函数功能：将string指向的字符串输出到标准输出设备（stdout），并将'\\0'转换为回车换行符'\\n'。在C语言中，字符串以’\\0’结尾。该函数不仅可以将字符串输出到标准输出设备，而且要将字符串的结束标志转换为回车换行。

返回值：成功则返回换行符，若失败则返回EOF。 例程如下应用puts函数向终端输出字符串。

#include int main(void) {

char string[] = \puts(string); return 0; }

例程说明：

（1）首先，将字符串\存入以string为首地址的缓冲区。 （2）应用puts函数将该字符串显示在标准输出设备上。 注意：该函数将字符串的结尾标志'\\0'转换为回车换行符'\\n'。因此，程序运行的结果为：

This is a test!

remove：删除文件函数

函数原型：int remove(char *filename); 头文件：#include 是否是标准函数：是

函数功能：删除以filename为文件名的文件。该函数的参数为欲删除文件的文件名，如果是单纯的文件名，就表明删除当前文件夹下的文件，否则要写明文件的路径。

返回值：成功删除文件返回0，否则返回-1。 例程如下应用remove函数删除文件。

#include void main() {

if( remove( \

perror( \else

printf( \}

例程说明：

（1）首先要在当前文件夹下建立文件test.txt。 （2）再利用remove函数删除该文件。若删除成功，则在终端显示字符串\\\n\，否则显示字符串\。

注意：前面已经讲过perror函数是按照一定格式要求向终端输出错误信息，因此，若删除文件成功，程序运行的结果为：

Deleted test.txt

若删除失败，则程序运行的结果为：

Could not delete test.txt!!: No such file or directory

这里，利用perror函数显示的完整的错误信息包括：用户自定义字符串，冒号，系统报错信息，换行符。

rename：重命名文件函数

函数原型：int rename(char *oldname, char *newname); 头文件：#include 是否是标准函数：是

函数功能：把由oldname所指的文件名改为由newname所指的文件名。该函数有两个参数，oldname为旧的文件名，newname为欲改成的新文件名。应当注意，oldname所指的文件一定要存在，newname所指的文件一定不存在。应用该函数可将一个文件的旧文件名oldname改为新文件名newname，但不能改变文件的路径。 返回值：成功返回0，出错返回-1。

例程如下应用rename函数重命名文件。

#include int main(void) {

if( rename(\printf(\else

printf(\}

例程说明：

（1）首先，在当前文件夹下建立一个文件\。

（2）应用rename函数重命名该文件，将其改名为\。若重命名成功，在屏幕上显示\提示字符串；否则显示\提示字符串。

rewind：重置文件指针函数

函数原型：void rewind(FILE *stream); 头文件：#include 是否是标准函数：是

函数功能：将文件指针fp重新定位在文件开头，并清除文件的结束标志和错误标志。该函数与函数fseek功能类似，但不同的是，该函数可以清除文件的结束标志和错误标志，而函数fseek不能；另外，该函数不能像函数fseek一样返回一个值表明操作是否成功，因为该函数无返回值。

返回值：无。

例程如下应用函数rewind重定位文件指针。

#include void main( void ) {

FILE *fp; int data1, data2; data1 = 1; data2 = 2;

if( (fp = fopen( \ {

fprintf( fp, \

printf( \ data1=0;

data2=0;

rewind( fp );

fscanf( fp, \

printf( \fclose( fp ); } }

例程说明：

（1）首先以写的方式打开一个名为\的文件。 （2）应用fprintf函数向该文件写入data1，data2两个整型数，其值分别为1，2。此时，文件指针fp已指向文件尾。

（3）在屏幕上显示这两个数。

（4）再将变量data1和data2置0。

（4）应用rewind函数重定位文件指针，将文件指针fp重新定位在文件开头。 （5）再应用fscanf函数向data1，data2两个变量中读入文件中的数字。 （6）在屏幕上显示这两个数。

注意：在应用fprintf函数向该文件写入data1，data2两个整型数后，文件指针fp会自动指向文件尾。只有再应用函数rewind、fseek才能将文件指针重新定位到文件开头，以便读取文件。本例中，将data1和data2置0的目的是为了说明应用fscanf函数向data1，data2两个变量中读入文件中的数字的结果是正确的。本程序的运行结果为：

The values written are: 1 and 2 The values read are: 1 and 2

scanf：格式化输入函数

函数原型：int scanf(char *format[,argument,...]); 头文件：#include 是否是标准函数：是

函数功能：从标准输入设备（键盘）按照format指定的格式字符串所规定的格式，将数据输入到argument所指定的内存单元。scanf函数与printf函数相对，前者是从标准输入设备输入数值，后者是从标准输出设备输出数值。

返回值：成功返回输入的字符个数，否则遇到结束符返回EOF，出错返回0。 例程如下应用scanf函数输入数据。

#include void main( void ) { int i; char ch; float f;

printf(\scanf(\getchar();

printf(\scanf(\getchar();

printf(\

scanf(\getchar();

printf(\}

例程说明：

（1）应用scanf函数向预先声明的三个变量空间输入一个整型数、一个字符、一个浮点数。

（2）在屏幕上显示这三个值。

注意：scanf函数与fscanf函数类似，但只能从标准输入设备文件读取数值，而不能像fscanf函数一样从一般用户自定义文件中读取数值。scanf函数常用作程序设计中数据的输入函数。

setbuf、setvbuf：指定文件流的缓冲区函数

函数原型：void setbuf(FILE *fp, char *buf); void setvbuf(FILE *fp, char *buf, int type, unsigned size); 头文件：#include 是否是标准函数：是

函数功能： 这两个函数使得打开文件后，用户可以建立自己的文件缓冲区，而不必使用fopen函数打开文件时设定的默认缓冲区。

setbuf函数的定义中，参数buf指定的缓冲区大小由stdio.h中定义的宏BUFSIZE的值决定，缺省值default为512字节。而当buf为NULL时，setbuf函数将使文件I/O不带缓冲区。而对setvbuf函数，则由malloc函数来分配缓冲区。参数size指明了缓冲区的长度(必须大于0)，而参数type则表明了缓冲的类型，其取值如下表：

setvbuf函数中参数type的取值含义

type 值 _IOFBF _IOLBF _IONBF 含义 文件全部缓冲，即缓冲区装满后，才能对文件读写 文件行缓冲，即缓冲区接收到一个换行符时，才能对文件读写 文件不缓冲，此时忽略buf,size的值，直接读写文件，不再经过文件缓冲区缓冲 返回值：无。 例程如下应用setbuf函数指定文件的缓冲区。

#include void main( void ) {

char buf[BUFSIZ]; FILE *fp1, *fp2;

if( ((fp1 = fopen( \ ((fp2 = fopen( \ {

/* 应用setbuf函数给文件流fp1指定缓冲区buf */ setbuf( fp1, buf );

/*显示缓冲区地址*/

printf( \ /* 文件流fp2不指定缓冲区*/ setbuf( fp2, NULL );

/*信息提示不分配缓冲区*/

printf( \fclose(fp1); fclose(fp2); } }

例程说明：

（1）首先开辟一个大小为BUFSIZ的缓冲区，用作指定文件的缓冲区。这里，BUFSIZE为stdio.h中定义的宏，缺省值为512字节。

（2）以追加的方式和写的方式打开名为\和\的文件。

（3）应用setbuf函数给文件流fp1指定缓冲区buf，其中buf为缓冲区的首地址。并在屏幕上显示该首地址。

（4）文件流fp2不指定缓冲区，也就是第二个参数设置为NULL。并信息提示不分配缓冲区。

（5）关闭两个文件。

注意：使用setbuf函数指定文件的缓冲区时，一定要在文件读写之前。一旦用户自己指定了文件的缓冲区，文件的读写就要在用户指定的缓冲区中进行，而不在系统默认指定的缓冲区中进行。函数setvbuf的用法与setbuf类似，只是它的缓冲区大小可以动态分配，由函数的参数指定，而且缓冲区的类型也可以由参数指定。

sprintf：向字符串写入格式化数据函数

函数原型：int sprintf(char *string, char *farmat [,argument,...]); 头文件：#include 是否是标准函数：是

函数功能：将格式化的数据存储到以string为首地址的缓冲区中。参数argument要被转化为farmat规定的格式，并按照这个规定的格式向字符串数组写入数据。这里应该注意，sprintf函数与printf函数和fprint函数不同，前者是向缓冲区（即数组）写入格式化数据，后者是向标准输出文件（stdout）和用户自定义文件输出格式化数据。

返回值：返回存储在string中数据的字节数。

例程如下应用sprintf函数向指定缓冲区写入数据。

#include #include int main(void) {

char str[80];

sprintf(str, \puts(str); return 0; }

例程说明：

（1）首先开辟一个80字节大小的缓冲区str，即：该缓冲区以str为首地址。 （2）再将指定的字符串写入缓冲区str中。其中，M_PI是math.h中定义的常量3.141593。 （3）应用puts函数向终端输出该字符串。

注意：puts函数的作用是把str指定的字符串输出到标准输出设备，并且将字符串结束标志'/0'转换为回车换行符。因此，该程序运行的结果是：

An approximation of Pi is 3.141593

除了规定字符串中的换行符外，程序还将'/0'转换为换行符。

sscanf：从缓冲区中读格式化字符串函数

函数原型：int sscanf(char *string, char *format[,argument,...]); 头文件：#include 是否是标准函数：是

函数功能：将string指定的数据读到argument所指定的位置。其中，参数argument是与format格式要求相符合的变量指针。也就是说，如果format指定的格式为\，则argument就必须是整型变量的指针。这里应该注意，sscanf函数与scanf函数和fscanf函数不同，前者是从指定的缓冲区读格式化数据到新的缓冲区中，而后者是从标准输入文件（stdin）和用户自定义文件中读取格式化数据到缓冲区中。

返回值：成功返回已分配空间的数量，返回0表示没用空间分配，返回EOF表示出错。 例程如下应用sscanf函数读取格式化数据。

#include void main( void ) {

char str[] = \char s[81]; char c; int i; float fp;

/* 从缓冲区str中读取数据 */ sscanf( str, \sscanf( str, \sscanf( str, \sscanf( str, \ /* 输出已读取的数据 */ printf( \ = %s\\n\printf( \printf( \ = %d\\n\printf( \ = %f\\n\}

例程说明：

（1）首先开辟一个以str为首地址的缓冲区，并初始化其内容。 （2）应用sscanf函数从缓冲区str中读取数据。分别以格式要求\、\、\、\读取，并存入相应的变量中。

（3）输出已读取的数据。

tmpfile：创建临时文件函数

函数原型：FILE *tmpfile(void); 头文件：#include 是否是标准函数：是

函数功能：创建一个临时文件。该文件以w+b（二进制读写）方式打开，当该文件被关闭时，该文件会被自动删除。

返回值：返回指向临时文件的指针，如果文件打不开则返回EOF。 例程如下创建一个临时文件。

#include #include int main(void) {

FILE *tempfp; tempfp = tmpfile(); if (tempfp)

printf(\else {

printf(\exit(1); }

sleep(20); return 0; }

例程说明： （1）首先应用tmpfile函数创建一个临时文件，并将文件指针赋值给FILE型变量tempfp。 （2）如果创建临时文件成功，则在终端显示提示：Temporary file be created!! （3）如果创建不成功，则显示提示：Unable to create the temporary file!! （4）程序挂起20秒。

注意：这里将程序挂起20秒的目的是为了让用户看到生成的临时文件。这是因为当程序执行完时，系统会自动删除临时文件，那样用户就感觉不到临时文件的创建了。当该程序运行时，会在当前文件夹下生成一个临时文件。

临时文件的作用是暂时存储程序运行过程中需要的数据，当程序运行完毕时，这些数据也就没有用了。

tmpnam：创建临时文件名函数

函数原型：char *tmpnam(char *string); 头文件：#include 是否是标准函数：是

函数功能：创建一个临时文件名，用以打开一个临时文件。 返回值：创建成功返回指向该文件名的指针，否则返回NULL。 例程如下

#include #include main() {

char tmp[10]; tmpnam(tmp);

printf(\ }

例程说明：

（1）首先定义一个字符型数组tmp。

（2）调用tmpnam函数生成一个临时文件名。 （3）打印出该临时文件名。

注意：应用函数tmpnam生成的临时文件名是不同于任何已存在文件名的有效文件名。

本函数用于给临时文件创建文件名。

ungetc：把字符退回到输入流函数

函数原型：int ungetc(char c, FILE *fp); 头文件：#include 是否是标准函数：是

函数功能：把字符c退回到fp所指向的文件流中，并清除文件的结束标志。fp所指向的文件既可以是用户自定义的文件，又可以是系统定义的标准文件。

返回值：成功返回字符c，否则返回EOF。

例程如下应用ungetc函数向标准输入文件退回字符。

#include #include int main( void ) {

int i=0; char ch;

puts(\ /* 读取字符直到输入非数字或EOF */

while((ch = getchar()) != EOF && isdigit(ch))

i = 10 * i + ch - 48; /* 将ASCII码转换为整数值*/ /* 如果输入非数字，将其退回输入流 */

if (ch != EOF) ungetc(ch, stdin);

printf(\ return 0; }

例程说明：

（1）首先从终端输入一串字符串，要求输入整型数字，并以非数字字符结尾。

（2）程序读取字符，直到输入非数字或EOF为止，并将数字字符串转换为整型数。例如：将字符串\转换为整型数123。

（3）再将结尾的非数字字符退回到标准输入文件（stdin）。 （4）显示退回到标准输入文件中的字符。

注意：所谓将结尾的非数字字符退回到标准输入文件，就是说将数字字符串后面的那个非数字字符退回到标准输入文件中去。例如：输入的字符串为\，那么退回的字符就是a。这样，程序将前面的字符串\转换为整型数123，并存入变量i中。a作为数字字符串输入的结束标志（因为 a是继数字字符之后的第一个非数字字符），被退回到标准输入文件（stdin）。于是，再调用getchar函数读取的字符就应该是刚刚退回到标准输入文件中的字符a。因此，本段例程的执行结果为：

Input an integer followed by a char: 123abc

i = 123, next char in buffer = a

即：输入的字符串中123 为整型数，接下来的字符为a。

本文来源：https://www.bwwdw.com/article/13i3.html