测试4
测试大礼包
爬虫实战特训课

C 标准库 - <stdio.h>

简介

stdio .h 头文件定义了三个变量类型、一些宏和各种函数来执行输入和输出。

库变量

下面是头文件 stdio.h 中定义的变量类型：

序号 变量 & 描述
1 size_t
这是无符号整数类型，它是 sizeof 关键字的结果。
2 FILE
这是一个适合存储文件流信息的对象类型。
3 fpos_t
这是一个适合存储文件中任何位置的对象类型。

库宏

下面是头文件 stdio.h 中定义的宏：

序号 宏 & 描述
1 NULL
这个宏是一个空指针常量的值。
2 _IOFBF、_IOLBF 和 _IONBF
这些宏扩展了带有特定值的整型常量表达式，并适用于 setvbuf 函数的第三个参数。
3 BUFSIZ
这个宏是一个整数，该整数代表了 setbuf 函数使用的缓冲区大小。
4 EOF
这个宏是一个表示已经到达文件结束的负整数。
5 FOPEN_MAX
这个宏是一个整数，该整数代表了系统可以同时打开的文件数量。
6 FILENAME_MAX
这个宏是一个整数，该整数代表了字符数组可以存储的文件名的最大长度。如果实现没有任何限制，则该值应为推荐的最大值。
7 L_tmpnam
这个宏是一个整数，该整数代表了字符数组可以存储的由 tmpnam 函数创建的临时文件名的最大长度。
8 SEEK_CUR、SEEK_END 和 SEEK_SET
这些宏是在These macros are used in the fseek 函数中使用，用于在一个文件中定位不同的位置。
9 TMP_MAX
这个宏是 tmpnam 函数可生成的独特文件名的最大数量。
10 stderr、stdin 和 stdout
这些宏是指向 FILE 类型的指针，分别对应于标准错误、标准输入和标准输出流。

库函数

下面是头文件 stdio.h 中定义的函数：

为了更好地理解函数，请按照下面的序列学习这些函数，因为第一个函数中创建的文件会在后续的函数中使用到。
序号 函数 & 描述
1 int fclose(FILE *stream)
关闭流 stream。刷新所有的缓冲区。
2 void clearerr(FILE *stream)
清除给定流 stream 的文件结束和错误标识符。
3 int feof(FILE *stream)
测试给定流 stream 的文件结束标识符。
4 int ferror(FILE *stream)
测试给定流 stream 的错误标识符。
5 int fflush(FILE *stream)
刷新流 stream 的输出缓冲区。
6 int fgetpos(FILE *stream, fpos_t *pos)
获取流 stream 的当前文件位置，并把它写入到 pos。
7 FILE *fopen(const char *filename, const char *mode)
使用给定的模式 mode 打开 filename 所指向的文件。
8 size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
从给定流 stream 读取数据到 ptr 所指向的数组中。
9 FILE *freopen(const char *filename, const char *mode, FILE *stream)
把一个新的文件名 filename 与给定的打开的流 stream 关联，同时关闭流中的旧文件。
10 int fseek(FILE *stream, long int offset, int whence)
设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 whence 位置查找的字节数。
11 int fsetpos(FILE *stream, const fpos_t *pos)
设置给定流 stream 的文件位置为给定的位置。参数 pos 是由函数 fgetpos 给定的位置。
12 long int ftell(FILE *stream)
返回给定流 stream 的当前文件位置。
13 size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
把 ptr 所指向的数组中的数据写入到给定流 stream 中。
14 int remove(const char *filename)
删除给定的文件名 filename，以便它不再被访问。
15 int rename(const char *old_filename, const char *new_filename)
把 old_filename 所指向的文件名改为 new_filename。
16 void rewind(FILE *stream)
设置文件位置为给定流 stream 的文件的开头。
17 void setbuf(FILE *stream, char *buffer)
定义流 stream 应如何缓冲。
18 int setvbuf(FILE *stream, char *buffer, int mode, size_t size)
另一个定义流 stream 应如何缓冲的函数。
19 FILE *tmpfile(void)
以二进制更新模式(wb+)创建临时文件。
20 char *tmpnam(char *str)
生成并返回一个有效的临时文件名，该文件名之前是不存在的。
21 int fprintf(FILE *stream, const char *format, ...)
发送格式化输出到流 stream 中。
22 int printf(const char *format, ...)
发送格式化输出到标准输出 stdout。
23 int sprintf(char *str, const char *format, ...)
发送格式化输出到字符串。
24 int vfprintf(FILE *stream, const char *format, va_list arg)
使用参数列表发送格式化输出到流 stream 中。
25 int vprintf(const char *format, va_list arg)
使用参数列表发送格式化输出到标准输出 stdout。
26 int vsprintf(char *str, const char *format, va_list arg)
使用参数列表发送格式化输出到字符串。
27 int fscanf(FILE *stream, const char *format, ...)
从流 stream 读取格式化输入。
28 int scanf(const char *format, ...)
从标准输入 stdin 读取格式化输入。
29 int sscanf(const char *str, const char *format, ...)
从字符串读取格式化输入。
30 int fgetc(FILE *stream)
从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。
31 char *fgets(char *str, int n, FILE *stream)
从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。
32 int fputc(int char, FILE *stream)
把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。
33 int fputs(const char *str, FILE *stream)
把字符串写入到指定的流 stream 中，但不包括空字符。
34 int getc(FILE *stream)
从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。
35 int getchar(void)
从标准输入 stdin 获取一个字符（一个无符号字符）。
36 char *gets(char *str)
从标准输入 stdin 读取一行，并把它存储在 str 所指向的字符串中。当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。
37 int putc(int char, FILE *stream)
把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。
38 int putchar(int char)
把参数 char 指定的字符（一个无符号字符）写入到标准输出 stdout 中。
39 int puts(const char *str)
把一个字符串写入到标准输出 stdout，直到空字符，但不包括空字符。换行符会被追加到输出中。
40 int ungetc(int char, FILE *stream)
把字符 char（一个无符号字符）推入到指定的流 stream 中，以便它是下一个被读取到的字符。
41 void perror(const char *str)
把一个描述性错误消息输出到标准错误 stderr。首先输出字符串 str，后跟一个冒号，然后是一个空格。

C 库函数 - fclose()

描述

C 库函数 int fclose(FILE *stream) 关闭流 stream。刷新所有的缓冲区。

声明

下面是 fclose() 函数的声明。

int fclose(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了要被关闭的流。

返回值

如果流成功关闭，则该方法返回零。如果失败，则返回 EOF。

实例

下面的实例演示了 fclose() 函数的用法。

#include <stdio.h>

int main()
{
   FILE *fp;
 
   fp = fopen("file.txt", "w");

   fprintf(fp, "%s", "这里是 w3cschool.cc");
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建一个文件 file.txt，然后写入下面的文本行，最后使用 fclose() 函数关闭文件。

这里是 w3cschool.cc

C 库函数 - clearerr()

描述

C 库函数 void clearerr(FILE *stream) 清除给定流 stream 的文件结束和错误标识符。

声明

下面是 clearerr() 函数的声明。

void clearerr(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

返回值

这不会失败，且不会设置外部变量 errno，但是如果它检测到它的参数不是一个有效的流，则返回 -1，并设置 errno 为 EBADF。

实例

下面的实例演示了 clearerr() 函数的用法。

#include <stdio.h>

int main()
{
   FILE *fp;
   char c;

   fp = fopen("file.txt", "w");

   c = fgetc(fp);
   if( ferror(fp) )
   {
      printf("读取文件：file.txt 时发生错误\n");
   }
   clearerr(fp);
   if( ferror(fp) )
   {
      printf("读取文件：file.txt 时发生错误\n");
   }
   fclose(fp);

   return(0);
}

假设我们有一个文本文件 file.txt，它是一个空文件。让我们编译并运行上面的程序，因为我们试图读取一个以只写模式打开的文件，这将产生以下结果。

读取文件：file.txt 时发生错误

C 库函数 - feof()

描述

C 库函数 int feof(FILE *stream) 测试给定流 stream 的文件结束标识符。

声明

下面是 feof() 函数的声明。

int feof(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

返回值

当设置了与流关联的文件结束标识符时，该函数返回一个非零值，否则返回零。

实例

下面的实例演示了 feof() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;
  
   fp = fopen("file.txt","r");
   if(fp == NULL) 
   {
      perror("打开文件时发生错误");
      return(-1);
   }
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      { 
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下所示。该文件将作为我们实例程序中的一个输入使用：

这里是 xuebiancheng.cn

让我们编译并运行上面的程序，这将产生以下结果：

这里是 xuebiancheng.cn

C 库函数 - ferror()

描述

C 库函数 int ferror(FILE *stream) 测试给定流 stream 的错误标识符。

声明

下面是 ferror() 函数的声明。

int ferror(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

返回值

如果设置了与流关联的错误标识符，该函数返回一个非零值，否则返回一个零值。

实例

下面的实例演示了 ferror() 函数的用法。

#include <stdio.h>

int main()
{
   FILE *fp;
   char c;

   fp = fopen("file.txt", "w");

   c = fgetc(fp);
   if( ferror(fp) )
   {
      printf("读取文件：file.txt 时发生错误\n");
   }
   clearerr(fp);
   if( ferror(fp) )
   {
      printf("读取文件：file.txt 时发生错误\n");
   }
   fclose(fp);

   return(0);
}

假设我们有一个文本文件 file.txt，它是一个空文件。让我们编译并运行上面的程序，因为我们试图读取一个以只写模式打开的文件，这将产生以下结果。

读取文件：file.txt 时发生错误

C 库函数 - fflush()

描述

C 库函数 int fflush(FILE *stream) 刷新流 stream 的输出缓冲区。

声明

下面是 fflush() 函数的声明。

int fflush(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个缓冲流。

返回值

如果成功，该函数返回零值。如果发生错误，则返回 EOF，且设置错误标识符（即 feof）。

实例

下面的实例演示了 fflush() 函数的用法。

#include <stdio.h>
#include <string.h>

int main()
{

   char buff[1024];

   memset( buff, '\0', sizeof( buff ));

   fprintf(stdout, "启用全缓冲\n");
   setvbuf(stdout, buff, _IOFBF, 1024);

   fprintf(stdout, "这里是 xuebiancheng.cn\n");
   fprintf(stdout, "该输出将保存到 buff\n");
   fflush( stdout );

   fprintf(stdout, "这将在编程时出现\n");
   fprintf(stdout, "最后休眠五秒钟\n");

   sleep(5);

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果。在这里，程序把缓冲输出保存到 buff，直到首次调用 fflush() 为止，然后开始缓冲输出，最后休眠 5 秒钟。它会在程序结束之前，发送剩余的输出到 STDOUT。

启用全缓冲
这里是 xuebiancheng.cn
该输出将保存到 buff
这将在编程时出现
最后休眠五秒钟

C 库函数 - fgetpos()

描述

C 库函数 int fgetpos(FILE *stream, fpos_t *pos) 获取流 stream 的当前文件位置，并把它写入到 pos。

声明

下面是 fgetpos() 函数的声明。

int fgetpos(FILE *stream, fpos_t *pos)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
  • pos -- 这是指向 fpos_t 对象的指针。

返回值

如果成功，该函数返回零。如果发生错误，则返回非零值。

实例

下面的实例演示了 fgetpos() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   fpos_t position;

   fp = fopen("file.txt","w+");
   fgetpos(fp, &position);
   fputs("Hello, World!", fp);
  
   fsetpos(fp, &position);
   fputs("这将覆盖之前的内容", fp);
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建一个文件 file.txt，它的内容如下。首先我们使用 fgetpos() 函数获取文件的初始位置，接着我们向文件写入 Hello, World!，然后我们使用 fsetpos() 函数来重置写指针到文件的开头，重写文件为下列内容：

这将覆盖之前的内容

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;
   int n = 0;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }

   fclose(fp);

   return(0);
}

C 库函数 - fopen()

描述

C 库函数 FILE *fopen(const char *filename, const char *mode) 使用给定的模式 mode 打开 filename 所指向的文件。

声明

下面是 fopen() 函数的声明。

FILE *fopen(const char *filename, const char *mode)

参数

  • filename -- 这是 C 字符串，包含了要打开的文件名称。
  • mode -- 这是 C 字符串，包含了文件访问模式，模式如下：
模式 描述
"r" 打开一个用于读取的文件。该文件必须存在。
"w" 创建一个用于写入的空文件。如果文件名称与已存在的文件相同，则会删除已有文件的内容，文件被视为一个新的空文件。
"a" 追加到一个文件。写操作向文件末尾追加数据。如果文件不存在，则创建文件。
"r+" 打开一个用于更新的文件，可读取也可写入。该文件必须存在。
"w+" 创建一个用于读写的空文件。
"a+" 打开一个用于读取和追加的文件。

返回值

该函数返回一个 FILE 指针。否则返回 NULL，且设置全局变量 errno 来标识错误。

实例

下面的实例演示了 fopen() 函数的用法。

#include <stdio.h>
#include <stdlib.h>

int main()
{
   FILE * fp;

   fp = fopen ("file.txt", "w+");
   fprintf(fp, "%s %s %s %d", "We", "are", "in", 2014);
   
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建一个带有一下内容的文件 file.txt：

We are in 2014

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;
  
   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      { 
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - fread()

描述

C 库函数 size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) 从给定流 stream 读取数据到 ptr 所指向的数组中。

声明

下面是 fread() 函数的声明。

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)

参数

  • ptr -- 这是指向带有最小尺寸 size*nmemb 字节的内存块的指针。
  • size -- 这是要读取的每个元素的大小，以字节为单位。
  • nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流。

返回值

成功读取的元素总数会以 size_t 对象返回，size_t 对象是一个整型数据类型。如果总数与 nmemb 参数不同，则可能发生了一个错误或者到达了文件末尾。

实例

下面的实例演示了 fread() 函数的用法。

#include <stdio.h>
#include <string.h>

int main()
{
   FILE *fp;
   char c[] = "This is w3cschool";
   char buffer[20];

   /* 打开文件用于读写 */
   fp = fopen("file.txt", "w+");

   /* 写入数据到文件 */
   fwrite(c, strlen(c) + 1, 1, fp);

   /* 查找文件的开头 */
   fseek(fp, SEEK_SET, 0);

   /* 读取并显示数据 */
   fread(buffer, strlen(c)+1, 1, fp);
   printf("%s\n", buffer);
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建一个文件 file.txt，然后写入内容 this is xuebiancheng。接下来我们使用 fseek() 函数来重置写指针到文件的开头，文件内容如下所示：

This is xuebiancheng

C 库函数 - freopen()

描述

C 库函数 FILE *freopen(const char *filename, const char *mode, FILE *stream) 把一个新的文件名 filename 与给定的打开的流 stream 关联，同时关闭流中的旧文件。

声明

下面是 freopen() 函数的声明。

FILE *freopen(const char *filename, const char *mode, FILE *stream)

参数

  • filename -- 这是 C 字符串，包含了要打开的文件名称。
  • mode -- 这是 C 字符串，包含了文件访问模式，模式如下：
模式 描述
"r" 打开一个用于读取的文件。该文件必须存在。
"w" 创建一个用于写入的空文件。如果文件名称与已存在的文件相同，则会删除已有文件的内容，文件被视为一个新的空文件。
"a" 追加到一个文件。写操作向文件末尾追加数据。如果文件不存在，则创建文件。
"r+" 打开一个用于更新的文件，可读取也可写入。该文件必须存在。
"w+" 创建一个用于读写的空文件。
"a+" 打开一个用于读取和追加的文件。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被重新打开的流。

返回值

如果文件成功打开，则函数返回一个指针，指向用于标识流的对象。否则，返回空指针。

实例

下面的实例演示了 freopen() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;

   printf("该文本重定向到 stdout\n");

   fp = freopen("file.txt", "w+", stdout);

   printf("该文本重定向到 file.txt\n");

   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将发送下列行到标准输出 STDOUT，因为起初我们并没有打开标准输出：

该文本重定向到 stdout

在调用 freopen() 之后，它会关联标准输出 STDOUT 到文件 file.txt，无论我们在标准输出 STDOUT 中写了什么都会被写入 file.txt，所以文件 file.txt 将有以下内容。

该文本重定向到 file.txt

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - fseek()

描述

C 库函数 int fseek(FILE *stream, long int offset, int whence) 设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 whence 位置查找的字节数。

声明

下面是 fseek() 函数的声明。

int fseek(FILE *stream, long int offset, int whence)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
  • offset -- 这是相对 whence 的偏移量，以字节为单位。
  • whence -- 这是表示开始添加偏移 offset 的位置。它一般指定为下列常量之一：
常量 描述
SEEK_SET 文件的开头
SEEK_CUR 文件指针的当前位置
SEEK_END 文件的末尾

返回值

如果成功，则该函数返回零，否则返回非零值。

实例

下面的实例演示了 fseek() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;

   fp = fopen("file.txt","w+");
   fputs("This is w3cschool.cc", fp);
  
   fseek( fp, 7, SEEK_SET );
   fputs(" C Programming Langauge", fp);
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建文件 file.txt，它的内容如下。最初程序创建文件和写入 This is w3cschool.cc，但是之后我们在第七个位置重置了写指针，并使用 puts() 语句来重写文件，内容如下：

This is C Programming Langauge

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - fsetpos()

描述

C 库函数 int fsetpos(FILE *stream, const fpos_t *pos) 设置给定流 stream 的文件位置为给定的位置。参数 pos 是由函数 fgetpos 给定的位置。

声明

下面是 fsetpos() 函数的声明。

int fsetpos(FILE *stream, const fpos_t *pos)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
  • pos -- 这是指向 fpos_t 对象的指针，该对象包含了之前通过 fgetpos 获得的位置。

返回值

如果成功，该函数返回零值，否则返回非零值，并设置全局变量 errno 为一个正值，该值可通过 perror 来解释。

实例

下面的实例演示了 fsetpos() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   fpos_t position;

   fp = fopen("file.txt","w+");
   fgetpos(fp, &position);
   fputs("Hello, World!", fp);
  
   fsetpos(fp, &position);
   fputs("这将覆盖之前的内容", fp);
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建一个文件 file.txt，它的内容如下。首先我们使用 fgetpos() 函数获取文件的初始位置，接着我们向文件写入 Hello, World!，然后我们使用 fsetpos() 函数来重置写指针到文件的开头，重写文件为下列内容：

这将覆盖之前的内容

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - ftell()

描述

C 库函数 long int ftell(FILE *stream) 返回给定流 stream 的当前文件位置。

声明

下面是 ftell() 函数的声明。

long int ftell(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

返回值

该函数返回位置标识符的当前值。如果发生错误，则返回 -1L，全局变量 errno 被设置为一个正值。

实例

下面的实例演示了 ftell() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   int len;

   fp = fopen("file.txt", "r");
   if( fp == NULL ) 
   {
      perror ("打开文件错误");
      return(-1);
   }
   fseek(fp, 0, SEEK_END);

   len = ftell(fp);
   fclose(fp);

   printf("file.txt 的总大小 = %d 字节\n", len);
   
   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下：

This is xuebiancheng.cn

让我们编译并运行上面的程序，如果文件内容如上所示，这将产生以下结果，否则会根据文件内容给出不同的结果：

file.txt 的总大小 = 21 字节

C 库函数 - fwrite()

描述

C 库函数 size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) 把 ptr 所指向的数组中的数据写入到给定流 stream 中。

声明

下面是 fwrite() 函数的声明。

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)

参数

  • ptr -- 这是指向要被写入的元素数组的指针。
  • size -- 这是要被写入的每个元素的大小，以字节为单位。
  • nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输出流。

返回值

如果成功，该函数返回一个 size_t 对象，表示元素的总数，该对象时一个整型数据类型。如果该数字与 nmemb 参数不同，则会显示一个错误。

实例

下面的实例演示了 fwrite() 函数的用法。

#include<stdio.h>

int main ()
{
   FILE *fp;
   char str[] = "This is w3cschool.cc";

   fp = fopen( "file.txt" , "w" );
   fwrite(str , 1 , sizeof(str) , fp );

   fclose(fp);
  
   return(0);
}

让我们编译并运行上面的程序，这将创建一个文件 file.txt，它的内容如下：

This is w3cschool.cc

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - remove()

描述

C 库函数 int remove(const char *filename) 删除给定的文件名 filename，以便它不再被访问。

声明

下面是 remove() 函数的声明。

int remove(const char *filename)

参数

  • filename -- 这是 C 字符串，包含了要被删除的文件名称。

返回值

如果成功，则返回零。如果错误，则返回 -1，并设置 errno。

实例

下面的实例演示了 remove() 函数的用法。

#include <stdio.h>
#include <string.h>

int main ()
{
   int ret;
   FILE *fp;
   char filename[] = "file.txt";

   fp = fopen(filename, "w");

   fprintf(fp, "%s", "这里是 w3cschool.cc");
   fclose(fp);
   
   ret = remove(filename);

   if(ret == 0) 
   {
      printf("文件删除成功");
   }
   else 
   {
      printf("错误：不能删除该文件");
   }
   
   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下。我们将使用上面的程序来删除该文件。让我们编译并运行上面的程序，这将生成下面的消息，且文件被永久删除。

文件删除成功

C 库函数 - rename()

描述

C 库函数 int rename(const char *old_filename, const char *new_filename) 把 old_filename 所指向的文件名改为 new_filename。

声明

下面是 rename() 函数的声明。

int rename(const char *old_filename, const char *new_filename)

参数

  • old_filename -- 这是 C 字符串，包含了要被重命名/移动的文件名称。
  • new_filename -- 这是 C 字符串，包含了文件的新名称。

返回值

如果成功，则返回零。如果错误，则返回 -1，并设置 errno。

实例

下面的实例演示了 rename() 函数的用法。

#include <stdio.h>

int main ()
{
   int ret;
   char oldname[] = "file.txt";
   char newname[] = "newfile.txt";
   
   ret = rename(oldname, newname);

   if(ret == 0) 
   {
      printf("文件重命名成功");
   }
   else 
   {
      printf("错误：不能重命名该文件");
   }
   
   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下。我们将使用上面的程序来重命名该文件。让我们编译并运行上面的程序，这将生成下面的消息，且文件被重命名为 newfile.txt 文件。

文件重命名成功

C 库函数 - rewind()

C 标准库 - <stdio.h> C 标准库 - <stdio.h>

描述

C 库函数 void rewind(FILE *stream) 设置文件位置为给定流 stream 的文件的开头。

声明

下面是 rewind() 函数的声明。

void rewind(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

返回值

该函数不返回任何值。

实例

下面的实例演示了 rewind() 函数的用法。

#include <stdio.h>

int main()
{
   char str[] = "This is runoob.com";
   FILE *fp;
   int ch;

   /* 首先让我们在文件中写入一些内容 */
   fp = fopen( "file.txt" , "w" );
   fwrite(str , 1 , sizeof(str) , fp );
   fclose(fp);

   fp = fopen( "file.txt" , "r" );
   while(1)
   {
      ch = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", ch);
   }
   rewind(fp);
   printf("\n");
   while(1)
   {
      ch = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", ch);
     
   }
   fclose(fp);

   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下：

This is xuebiancheng.cn

让我们编译并运行上面的程序，这将产生以下结果：

This is xuebiancheng.cn
This is xuebiancheng.cn

C 库函数 - setbuf()

C 标准库 - <stdio.h> C 标准库 - <stdio.h>

描述

C 库函数 void setbuf(FILE *stream, char *buffer) 定义流 stream 应如何缓冲。该函数应在与流 stream 相关的文件被打开时，且还未发生任何输入或输出操作之前被调用一次。

声明

下面是 setbuf() 函数的声明。

void setbuf(FILE *stream, char *buffer)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了一个打开的流。
  • buffer -- 这是分配给用户的缓冲，它的长度至少为 BUFSIZ 字节，BUFSIZ 是一个宏常量，表示数组的长度。

返回值

该函数不返回任何值。

实例

下面的实例演示了 setbuf() 函数的用法。

#include <stdio.h>

int main()
{
   char buf[BUFSIZ];

   setbuf(stdout, buf);
   puts("This is xuebiancheng.cn");

   fflush(stdout);
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果。在这里，程序在即将输出的时候，发送输出到 STDOUT，否则它将缓冲输出。您也可以使用 fflush() 函数来 to 刷新输出。

This is xuebiancheng.cn

C 库函数 - setvbuf()

描述

C 库函数 int setvbuf(FILE *stream, char *buffer, int mode, size_t size) 定义流 stream 应如何缓冲。

声明

下面是 setvbuf() 函数的声明。

int setvbuf(FILE *stream, char *buffer, int mode, size_t size)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了一个打开的流。
  • buffer -- 这是分配给用户的缓冲。如果设置为 NULL，该函数会自动分配一个指定大小的缓冲。
  • mode -- 这指定了文件缓冲的模式：
模式 描述
_IOFBF 全缓冲：对于输出，数据在缓冲填满时被一次性写入。对于输入，缓冲会在请求输入且缓冲为空时被填充。
_IOLBF 行缓冲：对于输出，数据在遇到换行符或者在缓冲填满时被写入，具体视情况而定。对于输入，缓冲会在请求输入且缓冲为空时被填充，直到遇到下一个换行符。
_IONBF 无缓冲：不使用缓冲。每个 I/O 操作都被即时写入。buffer 和 size 参数被忽略。
  • size --这是缓冲的大小，以字节为单位。

返回值

如果成功，则该函数返回 0，否则返回非零值。

实例

下面的实例演示了 setvbuf() 函数的用法。

#include <stdio.h>

int main()
{

   char buff[1024];

   memset( buff, '\0', sizeof( buff ));

   fprintf(stdout, "启用全缓冲\n");
   setvbuf(stdout, buff, _IOFBF, 1024);

   fprintf(stdout, "这里是 xuebiancheng.cn\n");
   fprintf(stdout, "该输出将保存到 buff\n");
   fflush( stdout );

   fprintf(stdout, "这将在编程时出现\n");
   fprintf(stdout, "最后休眠五秒钟\n");

   sleep(5);

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果。在这里，程序把缓冲输出保存到 buff，直到首次调用 fflush() 为止，然后开始缓冲输出，最后休眠 5 秒钟。它会在程序结束之前，发送剩余的输出到 STDOUT。

启用全缓冲
这里是 xuebiancheng.cn
该输出将保存到 buff
这将在编程时出现
最后休眠五秒钟

C 库函数 - tmpfile()

描述

C 库函数 FILE *tmpfile(void) 以二进制更新模式(wb+)创建临时文件。被创建的临时文件会在流关闭的时候或者在程序终止的时候自动删除。

声明

下面是 tmpfile() 函数的声明。

FILE *tmpfile(void)

参数

  • NA

返回值

如果成功，该函数返回一个指向被创建的临时文件的流指针。如果文件未被创建，则返回 NULL。

实例

下面的实例演示了 tmpfile() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;

   fp = tmpfile();
   printf("临时文件被创建\n");

   /* 您可以在这里使用临时文件 */

   fclose(fp);

   return(0);
}

让我们编译并运行上面的程序，它将在 /tmp 文件夹中创建一个临时文件，但是一旦程序退出，临时文件会被自动删除，且程序会产生以下结果：

临时文件被创建

C 库函数 - tmpnam()

描述

C 库函数 char *tmpnam(char *str) 生成并返回一个有效的临时文件名，该文件名之前是不存在的。如果 str 为空，则只会返回临时文件名。

声明

下面是 tmpnam() 函数的声明。

char *tmpnam(char *str)

参数

  • str -- 这是一个指向字符数组的指针，其中，临时文件名将被存储为 C 字符串。

返回值

  • 一个指向 C 字符串的指针，该字符串存储了临时文件名。如果 str 是一个空指针，则该指针指向一个内部缓冲区，缓冲区在下一次调用函数时被覆盖。
  • 如果 str 不是一个空指针，则返回 str。如果函数未能成功创建可用的文件名，则返回一个空指针。

实例

下面的实例演示了 tmpnam() 函数的用法。

#include <stdio.h>

int main()
{
   char buffer[L_tmpnam];
   char *ptr;


   tmpnam(buffer);
   printf("临时名称 1: %s\n", buffer);
 
   ptr = tmpnam(NULL);
   printf("临时名称 2: %s\n", ptr);

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

临时名称 1: /tmp/filebaalTb
临时名称 2: /tmp/filedCIbb0

C 库函数 - fprintf()

描述

C 库函数 int fprintf(FILE *stream, const char *format, ...) 发送格式化输出到流 stream 中。

声明

下面是 fprintf() 函数的声明。

int fprintf(FILE *stream, const char *format, ...)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
  • format -- 这是 C 字符串，包含了要被写入到流 stream 中的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。format 标签属性是 %[flags][width][.precision][length]specifier，具体讲解如下：
specifier（说明符） 输出
c 字符
d 或 i 有符号十进制整数
e 使用 e 字符的科学科学记数法（尾数和指数）
E 使用 E 字符的科学科学记数法（尾数和指数）
f 十进制浮点数
g 自动选择 %e 或 %f 中合适的表示法
G 自动选择 %E 或 %f 中合适的表示法
o 有符号八进制
s 字符的字符串
u 无符号十进制整数
x 无符号十六进制整数
X 无符号十六进制整数（大写字母）
p 指针地址
n 无输出
% 字符
 
flags（标识） 描述
- 在给定的字段宽度内左对齐，默认是右对齐（参见 width 子说明符）。
+ 强制在结果之前显示加号或减号（+ 或 -），即正数前面会显示 + 号。默认情况下，只有负数前面会显示一个 - 号。
(space) 如果没有写入任何符号，则在该值前面插入一个空格。
# 与 o、x 或 X 说明符一起使用时，非零值前面会分别显示 0、0x 或 0X。
与 e、E 和 f 一起使用时，会强制输出包含一个小数点，即使后边没有数字时也会显示小数点。默认情况下，如果后边没有数字时候，不会显示显示小数点。
与 g 或 G 一起使用时，结果与使用 e 或 E 时相同，但是尾部的零不会被移除。
0 在指定填充 padding 的数字左边放置零（0），而不是空格（参见 width 子说明符）。
 
width（宽度） 描述
(number) 要输出的字符的最小数目。如果输出的值短于该数，结果会用空格填充。如果输出的值长于该数，结果不会被截断。
* 宽度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
.precision（精度） 描述
.number 对于整数说明符（d、i、o、u、x、X）：precision 指定了要写入的数字的最小位数。如果写入的值短于该数，结果会用前导零来填充。如果写入的值长于该数，结果不会被截断。精度为 0 意味着不写入任何字符。
对于 e、E 和 f 说明符：要在小数点后输出的小数位数。
对于 g 和 G 说明符：要输出的最大有效位数。
对于 s: 要输出的最大字符数。默认情况下，所有字符都会被输出，直到遇到末尾的空字符。
对于 c 类型：没有任何影响。
当未指定任何精度时，默认为 1。如果指定时不带有一个显式值，则假定为 0。
.* 精度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
length（长度） 描述
h 参数被解释为短整型或无符号短整型（仅适用于整数说明符：i、d、o、u、x 和 X）。
l 参数被解释为长整型或无符号长整型，适用于整数说明符（i、d、o、u、x 和 X）及说明符 c（表示一个宽字符）和 s（表示宽字符字符串）。
L 参数被解释为长双精度型（仅适用于浮点数说明符：e、E、f、g 和 G）。
  • 附加参数 -- 根据不同的 format 字符串，函数可能需要一系列的附加参数，每个参数包含了一个要被插入的值，替换了 format 参数中指定的每个 % 标签。参数的个数应与 % 标签的个数相同。

返回值

如果成功，则返回写入的字符总数，否则返回一个负数。

实例

下面的实例演示了 fprintf() 函数的用法。

#include <stdio.h>
#include <stdlib.h>

int main()
{
   FILE * fp;

   fp = fopen ("file.txt", "w+");
   fprintf(fp, "%s %s %s %d", "We", "are", "in", 2014);
   
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建文件 file.txt，它的内容如下：

We are in 2014

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - printf()

描述

C 库函数 int printf(const char *format, ...) 发送格式化输出到标准输出 stdout。

printf()函数的调用格式为:

printf("<格式化字符串>", <参量表>);

声明

下面是 printf() 函数的声明。

int printf(const char *format, ...)

参数

  • format -- 这是字符串，包含了要被写入到标准输出 stdout 的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。format 标签属性是 %[flags][width][.precision][length]specifier，具体讲解如下：

格式字符 意义
d 以十进制形式输出带符号整数(正数不输出符号)
o 以八进制形式输出无符号整数(不输出前缀0)
x,X 以十六进制形式输出无符号整数(不输出前缀Ox)
u 以十进制形式输出无符号整数
f 以小数形式输出单、双精度实数
e,E 以指数形式输出单、双精度实数
g,G 以%f或%e中较短的输出宽度输出单、双精度实数
c 输出单个字符
s 输出字符串
p 输出指针地址
lu 32位无符号整数
llu 64位无符号整数
 
flags（标识） 描述
- 在给定的字段宽度内左对齐，默认是右对齐（参见 width 子说明符）。
+ 强制在结果之前显示加号或减号（+ 或 -），即正数前面会显示 + 号。默认情况下，只有负数前面会显示一个 - 号。
空格 如果没有写入任何符号，则在该值前面插入一个空格。
# 与 o、x 或 X 说明符一起使用时，非零值前面会分别显示 0、0x 或 0X。
与 e、E 和 f 一起使用时，会强制输出包含一个小数点，即使后边没有数字时也会显示小数点。默认情况下，如果后边没有数字时候，不会显示显示小数点。
与 g 或 G 一起使用时，结果与使用 e 或 E 时相同，但是尾部的零不会被移除。
0 在指定填充 padding 的数字左边放置零（0），而不是空格（参见 width 子说明符）。
 
width（宽度） 描述
(number) 要输出的字符的最小数目。如果输出的值短于该数，结果会用空格填充。如果输出的值长于该数，结果不会被截断。
* 宽度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
.precision（精度） 描述
.number 对于整数说明符（d、i、o、u、x、X）：precision 指定了要写入的数字的最小位数。如果写入的值短于该数，结果会用前导零来填充。如果写入的值长于该数，结果不会被截断。精度为 0 意味着不写入任何字符。
对于 e、E 和 f 说明符：要在小数点后输出的小数位数。
对于 g 和 G 说明符：要输出的最大有效位数。
对于 s: 要输出的最大字符数。默认情况下，所有字符都会被输出，直到遇到末尾的空字符。
对于 c 类型：没有任何影响。
当未指定任何精度时，默认为 1。如果指定时不带有一个显式值，则假定为 0。
.* 精度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
length（长度） 描述
h 参数被解释为短整型或无符号短整型（仅适用于整数说明符：i、d、o、u、x 和 X）。
l 参数被解释为长整型或无符号长整型，适用于整数说明符（i、d、o、u、x 和 X）及说明符 c（表示一个宽字符）和 s（表示宽字符字符串）。
L 参数被解释为长双精度型（仅适用于浮点数说明符：e、E、f、g 和 G）。

  • 附加参数 -- 根据不同的 format 字符串，函数可能需要一系列的附加参数，每个参数包含了一个要被插入的值，替换了 format 参数中指定的每个 % 标签。参数的个数应与 % 标签的个数相同。

返回值

如果成功，则返回写入的字符总数，否则返回一个负数。

实例

下面的实例演示了 printf() 函数的用法。

#include <stdio.h>

int main ()
{
   int ch;

   for( ch = 75 ; ch <= 100; ch++ ) {
      printf("ASCII 值 = %d, 字符 = %c\n", ch , ch );
   }

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

ASCII 值 = 75, 字符 = K
ASCII 值 = 76, 字符 = L
ASCII 值 = 77, 字符 = M
ASCII 值 = 78, 字符 = N
ASCII 值 = 79, 字符 = O
ASCII 值 = 80, 字符 = P
ASCII 值 = 81, 字符 = Q
ASCII 值 = 82, 字符 = R
ASCII 值 = 83, 字符 = S
ASCII 值 = 84, 字符 = T
ASCII 值 = 85, 字符 = U
ASCII 值 = 86, 字符 = V
ASCII 值 = 87, 字符 = W
ASCII 值 = 88, 字符 = X
ASCII 值 = 89, 字符 = Y
ASCII 值 = 90, 字符 = Z
ASCII 值 = 91, 字符 = [
ASCII 值 = 92, 字符 = \
ASCII 值 = 93, 字符 = ]
ASCII 值 = 94, 字符 = ^
ASCII 值 = 95, 字符 = _
ASCII 值 = 96, 字符 = `
ASCII 值 = 97, 字符 = a
ASCII 值 = 98, 字符 = b
ASCII 值 = 99, 字符 = c
ASCII 值 = 100, 字符 = d

以下实例输出各种格式化数据：

#include<stdio.h>
#include<string.h>
int main(void)
{
    charc,s[20],*p;
    inta=1234,*i;
    floatf=3.141592653589;
    doublex=0.12345678987654321;
    p="Howdoyoudo";
    strcpy(s,"Hello,Comrade");
    *i=12;
    c='\x41';
    printf("a=%d\n",a);       /*结果输出十进制整数a=1234*/
    printf("a=%6d\n",a);      /*结果输出6位十进制数a=1234*/
    printf("a=%06d\n",a);     /*结果输出6位十进制数a=001234*/
    printf("a=%2d\n",a);      /*a超过2位,按实际值输出a=1234*/
    printf("*i=%4d\n",*i);    /*输出4位十进制整数*i=12*/
    printf("*i=%-4d\n",*i);   /*输出左对齐4位十进制整数*i=12*/
    printf("i=%p\n",i);       /*输出地址i=06E4*/
    printf("f=%f\n",f);       /*输出浮点数f=3.141593*/
    printf("f=%6.4f\n",f);    /*输出6位其中小数点后4位的浮点数
    f=3.1416*/
    printf("x=%lf\n",x);      /*输出长浮点数x=0.123457*/
    printf("x=%18.16lf\n",x); /*输出18位其中小数点后16位的长浮点数x=0.1234567898765432*/
    printf("c=%c\n",c);       /*输出字符c=A*/
    printf("c=%x\n",c);       /*输出字符的ASCII码值c=41*/
    printf("s[]=%s\n",s);     /*输出数组字符串s[]=Hello,Comrade*/
    printf("s[]=%6.9s\n",s);  /*输出最多9个字符的字符串s[]=Hello,Co*/
    printf("s=%p\n",s);       /*输出数组字符串首字符地址s=FFBE*/
    printf("*p=%s\n",p);      /*输出指针字符串p=Howdoyoudo*/
    printf("p=%p\n",p);       /*输出指针的值p=0194*/
    getch();
    return 0;
}

C 库函数 - sprintf()

描述

C 库函数 int sprintf(char *str, const char *format, ...) 发送格式化输出到 str 所指向的字符串。

声明

下面是 sprintf() 函数的声明。

int sprintf(char *str, const char *format, ...)

参数

  • str -- 这是指向一个字符数组的指针，该数组存储了 C 字符串。
  • format -- 这是字符串，包含了要被写入到字符串 str 的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。format 标签属性是 %[flags][width][.precision][length]specifier，具体讲解如下：
specifier（说明符） 输出
c 字符
d 或 i 有符号十进制整数
e 使用 e 字符的科学科学记数法（尾数和指数）
E 使用 E 字符的科学科学记数法（尾数和指数）
f 十进制浮点数
g 自动选择 %e 或 %f 中合适的表示法
G 自动选择 %E 或 %f 中合适的表示法
o 有符号八进制
s 字符的字符串
u 无符号十进制整数
x 无符号十六进制整数
X 无符号十六进制整数（大写字母）
p 指针地址
n 无输出
% 字符
 
flags（标识） 描述
- 在给定的字段宽度内左对齐，默认是右对齐（参见 width 子说明符）。
+ 强制在结果之前显示加号或减号（+ 或 -），即正数前面会显示 + 号。默认情况下，只有负数前面会显示一个 - 号。
(space) 如果没有写入任何符号，则在该值前面插入一个空格。
# 与 o、x 或 X 说明符一起使用时，非零值前面会分别显示 0、0x 或 0X。
与 e、E 和 f 一起使用时，会强制输出包含一个小数点，即使后边没有数字时也会显示小数点。默认情况下，如果后边没有数字时候，不会显示显示小数点。
与 g 或 G 一起使用时，结果与使用 e 或 E 时相同，但是尾部的零不会被移除。
0 在指定填充 padding 的数字左边放置零（0），而不是空格（参见 width 子说明符）。
 
width（宽度） 描述
(number) 要输出的字符的最小数目。如果输出的值短于该数，结果会用空格填充。如果输出的值长于该数，结果不会被截断。
* 宽度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
.precision（精度） 描述
.number 对于整数说明符（d、i、o、u、x、X）：precision 指定了要写入的数字的最小位数。如果写入的值短于该数，结果会用前导零来填充。如果写入的值长于该数，结果不会被截断。精度为 0 意味着不写入任何字符。
对于 e、E 和 f 说明符：要在小数点后输出的小数位数。
对于 g 和 G 说明符：要输出的最大有效位数。
对于 s: 要输出的最大字符数。默认情况下，所有字符都会被输出，直到遇到末尾的空字符。
对于 c 类型：没有任何影响。
当未指定任何精度时，默认为 1。如果指定时不带有一个显式值，则假定为 0。
.* 精度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
length（长度） 描述
h 参数被解释为短整型或无符号短整型（仅适用于整数说明符：i、d、o、u、x 和 X）。
l 参数被解释为长整型或无符号长整型，适用于整数说明符（i、d、o、u、x 和 X）及说明符 c（表示一个宽字符）和 s（表示宽字符字符串）。
L 参数被解释为长双精度型（仅适用于浮点数说明符：e、E、f、g 和 G）。
  • 附加参数 -- 根据不同的 format 字符串，函数可能需要一系列的附加参数，每个参数包含了一个要被插入的值，替换了 format 参数中指定的每个 % 标签。参数的个数应与 % 标签的个数相同。

返回值

如果成功，则返回写入的字符总数，不包括字符串追加在字符串末尾的空字符。如果失败，则返回一个负数。

实例

下面的实例演示了 sprintf() 函数的用法。

#include <stdio.h>
#include <math.h>

int main()
{
   char str[80];

   sprintf(str, "Pi 的值 = %f", M_PI);
   puts(str);
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

Pi 的值 = 3.141593

C 库函数 - vfprintf()

描述

C 库函数 int vfprintf(FILE *stream, const char *format, va_list arg) 使用参数列表发送格式化输出到流 stream 中。

声明

下面是 vfprintf() 函数的声明。

int vfprintf(FILE *stream, const char *format, va_list arg)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
  • format -- 这是 C 字符串，包含了要被写入到流 stream 中的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。format 标签属性是 %[flags][width][.precision][length]specifier，具体讲解如下：
specifier（说明符） 输出
c 字符
d 或 i 有符号十进制整数
e 使用 e 字符的科学科学记数法（尾数和指数）
E 使用 E 字符的科学科学记数法（尾数和指数）
f 十进制浮点数
g 自动选择 %e 或 %f 中合适的表示法
G 自动选择 %E 或 %f 中合适的表示法
o 有符号八进制
s 字符的字符串
u 无符号十进制整数
x 无符号十六进制整数
X 无符号十六进制整数（大写字母）
p 指针地址
n 无输出
% 字符
 
flags（标识） 描述
- 在给定的字段宽度内左对齐，默认是右对齐（参见 width 子说明符）。
+ 强制在结果之前显示加号或减号（+ 或 -），即正数前面会显示 + 号。默认情况下，只有负数前面会显示一个 - 号。
(space) 如果没有写入任何符号，则在该值前面插入一个空格。
# 与 o、x 或 X 说明符一起使用时，非零值前面会分别显示 0、0x 或 0X。
与 e、E 和 f 一起使用时，会强制输出包含一个小数点，即使后边没有数字时也会显示小数点。默认情况下，如果后边没有数字时候，不会显示显示小数点。
与 g 或 G 一起使用时，结果与使用 e 或 E 时相同，但是尾部的零不会被移除。
0 在指定填充 padding 的数字左边放置零（0），而不是空格（参见 width 子说明符）。
 
width（宽度） 描述
(number) 要输出的字符的最小数目。如果输出的值短于该数，结果会用空格填充。如果输出的值长于该数，结果不会被截断。
* 宽度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
.precision（精度） 描述
.number 对于整数说明符（d、i、o、u、x、X）：precision 指定了要写入的数字的最小位数。如果写入的值短于该数，结果会用前导零来填充。如果写入的值长于该数，结果不会被截断。精度为 0 意味着不写入任何字符。
对于 e、E 和 f 说明符：要在小数点后输出的小数位数。
对于 g 和 G 说明符：要输出的最大有效位数。
对于 s: 要输出的最大字符数。默认情况下，所有字符都会被输出，直到遇到末尾的空字符。
对于 c 类型：没有任何影响。
当未指定任何精度时，默认为 1。如果指定时不带有一个显式值，则假定为 0。
.* 精度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
length（长度） 描述
h 参数被解释为短整型或无符号短整型（仅适用于整数说明符：i、d、o、u、x 和 X）。
l 参数被解释为长整型或无符号长整型，适用于整数说明符（i、d、o、u、x 和 X）及说明符 c（表示一个宽字符）和 s（表示宽字符字符串）。
L 参数被解释为长双精度型（仅适用于浮点数说明符：e、E、f、g 和 G）。
  • arg -- 一个表示可变参数列表的对象。这应被 <stdarg> 中定义的 va_start 宏初始化。

返回值

如果成功，则返回写入的字符总数，否则返回一个负数。

实例

下面的实例演示了 vfprintf() 函数的用法。

#include <stdio.h>
#include <stdarg.h>

void WriteFrmtd(FILE *stream, char *format, ...)
{
   va_list args;

   va_start(args, format);
   vfprintf(stream, format, args);
   va_end(args);
}

int main ()
{
   FILE *fp;

   fp = fopen("file.txt","w");

   WriteFrmtd(fp, "This is just one argument %d \n", 10);

   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将打开当前目录中的文件 file.txt，并写入以下内容：

This is just one argument 10

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - vprintf()

描述

C 库函数 int vprintf(const char *format, va_list arg) 使用参数列表发送格式化输出到标准输出 stdout。

声明

下面是 vprintf() 函数的声明。

int vprintf(const char *format, va_list arg)

参数

  • format -- 这是字符串，包含了要被写入到标准输出 stdout 的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。format 标签属性是 %[flags][width][.precision][length]specifier，具体讲解如下：
specifier（说明符） 输出
c 字符
d 或 i 有符号十进制整数
e 使用 e 字符的科学科学记数法（尾数和指数）
E 使用 E 字符的科学科学记数法（尾数和指数）
f 十进制浮点数
g 自动选择 %e 或 %f 中合适的表示法
G 自动选择 %E 或 %f 中合适的表示法
o 有符号八进制
s 字符的字符串
u 无符号十进制整数
x 无符号十六进制整数
X 无符号十六进制整数（大写字母）
p 指针地址
n 无输出
% 字符
 
flags（标识） 描述
- 在给定的字段宽度内左对齐，默认是右对齐（参见 width 子说明符）。
+ 强制在结果之前显示加号或减号（+ 或 -），即正数前面会显示 + 号。默认情况下，只有负数前面会显示一个 - 号。
(space) 如果没有写入任何符号，则在该值前面插入一个空格。
# 与 o、x 或 X 说明符一起使用时，非零值前面会分别显示 0、0x 或 0X。
与 e、E 和 f 一起使用时，会强制输出包含一个小数点，即使后边没有数字时也会显示小数点。默认情况下，如果后边没有数字时候，不会显示显示小数点。
与 g 或 G 一起使用时，结果与使用 e 或 E 时相同，但是尾部的零不会被移除。
0 在指定填充 padding 的数字左边放置零（0），而不是空格（参见 width 子说明符）。
 
width（宽度） 描述
(number) 要输出的字符的最小数目。如果输出的值短于该数，结果会用空格填充。如果输出的值长于该数，结果不会被截断。
* 宽度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
.precision（精度） 描述
.number 对于整数说明符（d、i、o、u、x、X）：precision 指定了要写入的数字的最小位数。如果写入的值短于该数，结果会用前导零来填充。如果写入的值长于该数，结果不会被截断。精度为 0 意味着不写入任何字符。
对于 e、E 和 f 说明符：要在小数点后输出的小数位数。
对于 g 和 G 说明符：要输出的最大有效位数。
对于 s: 要输出的最大字符数。默认情况下，所有字符都会被输出，直到遇到末尾的空字符。
对于 c 类型：没有任何影响。
当未指定任何精度时，默认为 1。如果指定时不带有一个显式值，则假定为 0。
.* 精度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
length（长度） 描述
h 参数被解释为短整型或无符号短整型（仅适用于整数说明符：i、d、o、u、x 和 X）。
l 参数被解释为长整型或无符号长整型，适用于整数说明符（i、d、o、u、x 和 X）及说明符 c（表示一个宽字符）和 s（表示宽字符字符串）。
L 参数被解释为长双精度型（仅适用于浮点数说明符：e、E、f、g 和 G）。
  • arg -- 一个表示可变参数列表的对象。这应被 <stdarg> 中定义的 va_start 宏初始化。

返回值

如果成功，则返回写入的字符总数，否则返回一个负数。

实例

下面的实例演示了 vprintf() 函数的用法。

#include <stdio.h>
#include <stdarg.h>

void WriteFrmtd(char *format, ...)
{
   va_list args;
   
   va_start(args, format);
   vprintf(format, args);
   va_end(args);
}

int main ()
{
   WriteFrmtd("%d variable argument\n", 1);
   WriteFrmtd("%d variable %s\n", 2, "arguments");
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

1 variable argument
2 variable arguments

C 库函数 - vsprintf()

描述

C 库函数 int vsprintf(char *str, const char *format, va_list arg) 使用参数列表发送格式化输出到字符串。

声明

下面是 vsprintf() 函数的声明。

int vsprintf(char *str, const char *format, va_list arg)

参数

  • str -- 这是指向一个字符数组的指针，该数组存储了 C 字符串。
  • format -- 这是字符串，包含了要被写入到字符串 str 的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。format 标签属性是 %[flags][width][.precision][length]specifier，具体讲解如下：
specifier（说明符） 输出
c 字符
d 或 i 有符号十进制整数
e 使用 e 字符的科学科学记数法（尾数和指数）
E 使用 E 字符的科学科学记数法（尾数和指数）
f 十进制浮点数
g 自动选择 %e 或 %f 中合适的表示法
G 自动选择 %E 或 %f 中合适的表示法
o 有符号八进制
s 字符的字符串
u 无符号十进制整数
x 无符号十六进制整数
X 无符号十六进制整数（大写字母）
p 指针地址
n 无输出
% 字符
 
flags（标识） 描述
- 在给定的字段宽度内左对齐，默认是右对齐（参见 width 子说明符）。
+ 强制在结果之前显示加号或减号（+ 或 -），即正数前面会显示 + 号。默认情况下，只有负数前面会显示一个 - 号。
(space) 如果没有写入任何符号，则在该值前面插入一个空格。
# 与 o、x 或 X 说明符一起使用时，非零值前面会分别显示 0、0x 或 0X。
与 e、E 和 f 一起使用时，会强制输出包含一个小数点，即使后边没有数字时也会显示小数点。默认情况下，如果后边没有数字时候，不会显示显示小数点。
与 g 或 G 一起使用时，结果与使用 e 或 E 时相同，但是尾部的零不会被移除。
0 在指定填充 padding 的数字左边放置零（0），而不是空格（参见 width 子说明符）。
 
width（宽度） 描述
(number) 要输出的字符的最小数目。如果输出的值短于该数，结果会用空格填充。如果输出的值长于该数，结果不会被截断。
* 宽度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
.precision（精度） 描述
.number 对于整数说明符（d、i、o、u、x、X）：precision 指定了要写入的数字的最小位数。如果写入的值短于该数，结果会用前导零来填充。如果写入的值长于该数，结果不会被截断。精度为 0 意味着不写入任何字符。
对于 e、E 和 f 说明符：要在小数点后输出的小数位数。
对于 g 和 G 说明符：要输出的最大有效位数。
对于 s: 要输出的最大字符数。默认情况下，所有字符都会被输出，直到遇到末尾的空字符。
对于 c 类型：没有任何影响。
当未指定任何精度时，默认为 1。如果指定时不带有一个显式值，则假定为 0。
.* 精度在 format 字符串中未指定，但是会作为附加整数值参数放置于要被格式化的参数之前。
 
length（长度） 描述
h 参数被解释为短整型或无符号短整型（仅适用于整数说明符：i、d、o、u、x 和 X）。
l 参数被解释为长整型或无符号长整型，适用于整数说明符（i、d、o、u、x 和 X）及说明符 c（表示一个宽字符）和 s（表示宽字符字符串）。
L 参数被解释为长双精度型（仅适用于浮点数说明符：e、E、f、g 和 G）。
  • arg -- 一个表示可变参数列表的对象。这应被 <stdarg> 中定义的 va_start 宏初始化。

返回值

如果成功，则返回写入的字符总数，否则返回一个负数。

实例

下面的实例演示了 vsprintf() 函数的用法。

#include <stdio.h>
#include <stdarg.h>

char buffer[80];
int vspfunc(char *format, ...)
{
   va_list aptr;
   int ret;

   va_start(aptr, format);
   ret = vsprintf(buffer, format, aptr);
   va_end(aptr);

   return(ret);
}

int main()
{
   int i = 5;
   float f = 27.0;
   char str[50] = "w3cschool.cc";

   vspfunc("%d %f %s", i, f, str);
   printf("%s\n", buffer);
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

5 27.000000 w3cschool.cc

C 库函数 - fscanf()

描述

C 库函数 int fscanf(FILE *stream, const char *format, ...) 从流 stream 读取格式化输入。

声明

下面是 fscanf() 函数的声明。

int fscanf(FILE *stream, const char *format, ...)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
  • format -- 这是 C 字符串，包含了以下各项中的一个或多个：空格字符、非空格字符 和 format 说明符。
    format 说明符形式为 [=%[*][width][modifiers]type=]，具体讲解如下：
参数 描述
* 这是一个可选的星号，表示数据是从流 stream 中读取的，但是可以被忽视，即它不存储在对应的参数中。
width 这指定了在当前读取操作中读取的最大字符数。
modifiers 为对应的附加参数所指向的数据指定一个不同于整型（针对 d、i 和 n）、无符号整型（针对 o、u 和 x）或浮点型（针对 e、f 和 g）的大小： h ：短整型（针对 d、i 和 n），或无符号短整型（针对 o、u 和 x） l ：长整型（针对 d、i 和 n），或无符号长整型（针对 o、u 和 x），或双精度型（针对 e、f 和 g） L ：长双精度型（针对 e、f 和 g）
type 一个字符，指定了要被读取的数据类型以及数据读取方式。具体参见下一个表格。

fscanf 类型说明符：

类型 合格的输入 参数的类型
c 单个字符：读取下一个字符。如果指定了一个不为 1 的宽度 width，函数会读取 width 个字符，并通过参数传递，把它们存储在数组中连续位置。在末尾不会追加空字符。 char *
d 十进制整数：数字前面的 + 或 - 号是可选的。 int *
e,E,f,g,G 浮点数：包含了一个小数点、一个可选的前置符号 + 或 -、一个可选的后置字符 e 或 E，以及一个十进制数字。两个有效的实例 -732.103 和 7.12e4 float *
o 八进制整数。 int *
s 字符串。这将读取连续字符，直到遇到一个空格字符（空格字符可以是空白、换行和制表符）。 char *
u 无符号的十进制整数。 unsigned int *
x,X 十六进制整数。 int *
  • 附加参数 -- 根据不同的 format 字符串，函数可能需要一系列的附加参数，每个参数包含了一个要被插入的值，替换了 format 参数中指定的每个 % 标签。参数的个数应与 % 标签的个数相同。

返回值

如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。

实例

下面的实例演示了 fscanf() 函数的用法。

#include <stdio.h>
#include <stdlib.h>


int main()
{
   char str1[10], str2[10], str3[10];
   int year;
   FILE * fp;

   fp = fopen ("file.txt", "w+");
   fputs("We are in 2014", fp);
   
   rewind(fp);
   fscanf(fp, "%s %s %s %d", str1, str2, str3, &year);
   
   printf("Read String1 |%s|\n", str1 );
   printf("Read String2 |%s|\n", str2 );
   printf("Read String3 |%s|\n", str3 );
   printf("Read Integer |%d|\n", year );

   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

Read String1 |We|
Read String2 |are|
Read String3 |in|
Read Integer |2014|

C 库函数 - scanf()

描述

C 库函数 int scanf(const char *format, ...) 从标准输入 stdin 读取格式化输入。

声明

下面是 scanf() 函数的声明。

int scanf(const char *format, ...)

参数

  • format -- 这是 C 字符串，包含了以下各项中的一个或多个：空格字符、非空格字符 和 format 说明符。
    format 说明符形式为 [=%[*][width][modifiers]type=]，具体讲解如下：
参数 描述
* 这是一个可选的星号，表示数据是从流 stream 中读取的，但是可以被忽视，即它不存储在对应的参数中。
width 这指定了在当前读取操作中读取的最大字符数。
modifiers 为对应的附加参数所指向的数据指定一个不同于整型（针对 d、i 和 n）、无符号整型（针对 o、u 和 x）或浮点型（针对 e、f 和 g）的大小： h ：短整型（针对 d、i 和 n），或无符号短整型（针对 o、u 和 x） l ：长整型（针对 d、i 和 n），或无符号长整型（针对 o、u 和 x），或双精度型（针对 e、f 和 g） L ：长双精度型（针对 e、f 和 g）
type 一个字符，指定了要被读取的数据类型以及数据读取方式。具体参见下一个表格。

scanf 类型说明符：

类型 合格的输入 参数的类型
c 单个字符：读取下一个字符。如果指定了一个不为 1 的宽度 width，函数会读取 width 个字符，并通过参数传递，把它们存储在数组中连续位置。在末尾不会追加空字符。 char *
d 十进制整数：数字前面的 + 或 - 号是可选的。 int *
e,E,f,g,G 浮点数：包含了一个小数点、一个可选的前置符号 + 或 -、一个可选的后置字符 e 或 E，以及一个十进制数字。两个有效的实例 -732.103 和 7.12e4 float *
o 八进制整数。 int *
s 字符串。这将读取连续字符，直到遇到一个空格字符（空格字符可以是空白、换行和制表符）。 char *
u 无符号的十进制整数。 unsigned int *
x,X 十六进制整数。 int *
  • 附加参数 -- 根据不同的 format 字符串，函数可能需要一系列的附加参数，每个参数包含了一个要被插入的值，替换了 format 参数中指定的每个 % 标签。参数的个数应与 % 标签的个数相同。

返回值

如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。

实例

下面的实例演示了 scanf() 函数的用法。

#include <stdio.h>

int main()
{
   char str1[20], str2[30];

   printf("请输入用户名：");
   scanf("%s", &str1);

   printf("请输入您的网站：");
   scanf("%s", &str2);

   printf("输入的用户名：%s\n", str1);
   printf("输入的网站：%s", str2);
   
   return(0);
}

让我们编译并运行上面的程序，这将在交互模式下产生以下结果：

请输入用户名：admin
请输入您的网站：www.runoob.com

输入的用户名：admin
输入的网站：www.runoob.com

C 库函数 - sscanf()

描述

C 库函数 int sscanf(const char *str, const char *format, ...) 从字符串读取格式化输入。

声明

下面是 sscanf() 函数的声明。

int sscanf(const char *str, const char *format, ...)

参数

  • str -- 这是 C 字符串，是函数检索数据的源。
  • format -- 这是 C 字符串，包含了以下各项中的一个或多个：空格字符、非空格字符 和 format 说明符。
    format 说明符形式为 [=%[*][width][modifiers]type=]，具体讲解如下：
参数 描述
* 这是一个可选的星号，表示数据是从流 stream 中读取的，但是可以被忽视，即它不存储在对应的参数中。
width 这指定了在当前读取操作中读取的最大字符数。
modifiers 为对应的附加参数所指向的数据指定一个不同于整型（针对 d、i 和 n）、无符号整型（针对 o、u 和 x）或浮点型（针对 e、f 和 g）的大小： h ：短整型（针对 d、i 和 n），或无符号短整型（针对 o、u 和 x） l ：长整型（针对 d、i 和 n），或无符号长整型（针对 o、u 和 x），或双精度型（针对 e、f 和 g） L ：长双精度型（针对 e、f 和 g）
type 一个字符，指定了要被读取的数据类型以及数据读取方式。具体参见下一个表格。

sscanf 类型说明符：

类型 合格的输入 参数的类型
c 单个字符：读取下一个字符。如果指定了一个不为 1 的宽度 width，函数会读取 width 个字符，并通过参数传递，把它们存储在数组中连续位置。在末尾不会追加空字符。 char *
d 十进制整数：数字前面的 + 或 - 号是可选的。 int *
e,E,f,g,G 浮点数：包含了一个小数点、一个可选的前置符号 + 或 -、一个可选的后置字符 e 或 E，以及一个十进制数字。两个有效的实例 -732.103 和 7.12e4 float *
o 八进制整数。 int *
s 字符串。这将读取连续字符，直到遇到一个空格字符（空格字符可以是空白、换行和制表符）。 char *
u 无符号的十进制整数。 unsigned int *
x,X 十六进制整数。 int *
  • 附加参数 -- 这个函数接受一系列的指针作为附加参数，每一个指针都指向一个对象，对象类型由 format 字符串中相应的 % 标签指定，参数与 % 标签的顺序相同。

     

    针对检索数据的 format 字符串中的每个 format 说明符，应指定一个附加参数。如果您想要把 sscanf 操作的结果存储在一个普通的变量中，您应该在标识符前放置引用运算符（&），例如：

        int n;
    sscanf (str,"%d",&amp;n);

返回值

如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。

实例

下面的实例演示了 sscanf() 函数的用法。

#include <stdio.h>
#include <stdlib.h>

int main()
{
   int day, year;
   char weekday[20], month[20], dtm[100];

   strcpy( dtm, "Saturday March 25 1989" );
   sscanf( dtm, "%s %s %d  %d", weekday, month, &day, &year );

   printf("%s %d, %d = %s\n", month, day, year, weekday );
    
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

March 25, 1989 = Saturday

C 库函数 - fgetc()

描述

C 库函数 int fgetc(FILE *stream) 从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。

声明

下面是 fgetc() 函数的声明。

int fgetc(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要在上面执行操作的流。

返回值

该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF。

实例

下面的实例演示了 fgetc() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;
   int n = 0;
  
   fp = fopen("file.txt","r");
   if(fp == NULL) 
   {
      perror("打开文件时发生错误");
      return(-1);
   }
   do
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }while(1);

   fclose(fp);
   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下。文件将作为实例中的输入：

We are in 2017

让我们编译并运行上面的程序，这将产生以下结果：

We are in 2017

C 库函数 - fgets()

描述

C 库函数 char *fgets(char *str, int n, FILE *stream) 从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

声明

下面是 fgets() 函数的声明。

char *fgets(char *str, int n, FILE *stream)

参数

  • str -- 这是指向一个字符数组的指针，该数组存储了要读取的字符串。
  • n -- 这是要读取的最大字符数（包括最后的空字符）。通常是使用以 str 传递的数组长度。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要从中读取字符的流。

返回值

如果成功，该函数返回相同的 str 参数。如果到达文件末尾或者没有读取到任何字符，str 的内容保持不变，并返回一个空指针。

如果发生错误，返回一个空指针。

实例

下面的实例演示了 fgets() 函数的用法。

#include <stdio.h>

int main()
{
   FILE *fp;
   char str[60];

   /* 打开用于读取的文件 */
   fp = fopen("file.txt" , "r");
   if(fp == NULL) {
      perror("打开文件时发生错误");
      return(-1);
   }
   if( fgets (str, 60, fp)!=NULL ) {
      /* 向标准输出 stdout 写入内容 */
      puts(str);
   }
   fclose(fp);
   
   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下。文件将作为实例中的输入：

We are in 2017

让我们编译并运行上面的程序，这将产生以下结果：

We are in 2017

C 库函数 - fputc()

描述

C 库函数 int fputc(int char, FILE *stream) 把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。

声明

下面是 fputc() 函数的声明。

int fputc(int char, FILE *stream)

参数

  • char -- 这是要被写入的字符。该字符以其对应的 int 值进行传递。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符的流。

返回值

如果没有发生错误，则返回被写入的字符。如果发生错误，则返回 EOF，并设置错误标识符。

实例

下面的实例演示了 fputc() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   int ch;

   fp = fopen("file.txt", "w+");
   for( ch = 33 ; ch <= 100; ch++ )
   {
      fputc(ch, fp);
   }
   fclose(fp);

   return(0);
}

让我们编译并运行上面的程序，这将在当前目录中创建文件 file.txt，它的内容如下：

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - fputs()

描述

C 库函数 int fputs(const char *str, FILE *stream) 把字符串写入到指定的流 stream 中，但不包括空字符。

声明

下面是 fputs() 函数的声明。

int fputs(const char *str, FILE *stream)

参数

  • str -- 这是一个数组，包含了要写入的以空字符终止的字符序列。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符串的流。

返回值

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

实例

下面的实例演示了 fputs() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;

   fp = fopen("file.txt", "w+");

   fputs("这是 C 语言。", fp);
   fputs("这是一种系统程序设计语言。", fp);

   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建文件 file.txt，它的内容如下：

这是 C 语言。这是一种系统程序设计语言。

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - getc()

描述

C 库函数 int getc(FILE *stream) 从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。

声明

下面是 getc() 函数的声明。

int getc(FILE *stream)

参数

  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要在上面执行操作的流。

返回值

该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF。

实例

下面的实例演示了 getc() 函数的用法。

#include<stdio.h>

int main()
{
   char c;

   printf("请输入字符：");
   c = getc(stdin);
   printf("输入的字符：");
   putc(c, stdout);
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

请输入字符：a
输入的字符：a

C 库函数 - getchar()

描述

C 库函数 int getchar(void) 从标准输入 stdin 获取一个字符（一个无符号字符）。这等同于 getc 带有 stdin 作为参数。

声明

下面是 getchar() 函数的声明。

int getchar(void)

参数

  • NA

返回值

该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF。

实例

下面的实例演示了 getchar() 函数的用法。

#include <stdio.h>

int main ()
{
   char c;
 
   printf("请输入字符：");
   c = getchar();
 
   printf("输入的字符：");
   putchar(c);

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

请输入字符：a
输入的字符：a

C 库函数 - gets()

描述

C 库函数 char *gets(char *str) 从标准输入 stdin 读取一行，并把它存储在 str 所指向的字符串中。当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

声明

下面是 gets() 函数的声明。

char *gets(char *str)

参数

  • str -- 这是指向一个字符数组的指针，该数组存储了 C 字符串。

返回值

如果成功，该函数返回 str。如果发生错误或者到达文件末尾时还未读取任何字符，则返回 NULL。

实例

下面的实例演示了 gets() 函数的用法。

#include <stdio.h>

int main()
{
   char str[50];

   printf("请输入一个字符串：");
   gets(str);

   printf("您输入的字符串是：%s", str);

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

请输入一个字符串：xuebiancheng.cn
您输入的字符串是：xuebiancheng.cn

C 库函数 - putc()

描述

C 库函数 int putc(int char, FILE *stream) 把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。

声明

下面是 putc() 函数的声明。

int putc(int char, FILE *stream)

参数

  • char -- 这是要被写入的字符。该字符以其对应的 int 值进行传递。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符的流。

返回值

该函数以无符号 char 强制转换为 int 的形式返回写入的字符，如果发生错误则返回 EOF。

实例

下面的实例演示了 putc() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   int ch;

   fp = fopen("file.txt", "w");
   for( ch = 33 ; ch <= 100; ch++ ) 
   {
      putc(ch, fp);
   }
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将在当前目录中创建文件 file.txt，它的内容如下：

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd

现在让我们使用下面的程序查看上面文件的内容：

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;

   fp = fopen("file.txt","r");
   while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", c);
   }
   fclose(fp);
   return(0);
}

C 库函数 - putchar()

描述

C 库函数 int putchar(int char) 把参数 char 指定的字符（一个无符号字符）写入到标准输出 stdout 中。

声明

下面是 putchar() 函数的声明。

int putchar(int char)

参数

  • char -- 这是要被写入的字符。该字符以其对应的 int 值进行传递。

返回值

该函数以无符号 char 强制转换为 int 的形式返回写入的字符，如果发生错误则返回 EOF。

实例

下面的实例演示了 putchar() 函数的用法。

#include <stdio.h>

int main ()
{
   char ch;

   for(ch = 'A' ; ch <= 'Z' ; ch++) {
      putchar(ch);
   }
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

ABCDEFGHIJKLMNOPQRSTUVWXYZ

C 库函数 - puts()

描述

C 库函数 int puts(const char *str) 把一个字符串写入到标准输出 stdout，直到空字符，但不包括空字符。换行符会被追加到输出中。

声明

下面是 puts() 函数的声明。

int puts(const char *str)

参数

  • str -- 这是要被写入的 C 字符串。

返回值

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

实例

下面的实例演示了 puts() 函数的用法。

#include <stdio.h>
#include <string.h>

int main()
{
   char str1[15];
   char str2[15];

   strcpy(str1, "xuebiancheng");
   strcpy(str2, "xbcbird");

   puts(str1);
   puts(str2);
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

xuebiancheng
xbcbird

C 库函数 - ungetc()

描述

C 库函数 int ungetc(int char, FILE *stream) 把字符 char（一个无符号字符）推入到指定的流 stream 中，以便它是下一个被读取到的字符。

声明

下面是 ungetc() 函数的声明。

int ungetc(int char, FILE *stream)

参数

  • char -- 这是要被推入的字符。该字符以其对应的 int 值进行传递。
  • stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了输入流。

返回值

如果成功，则返回被推入的字符，否则返回 EOF，且流 stream 保持不变。

实例

下面的实例演示了 ungetc() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;
   char buffer [256];

   fp = fopen("file.txt", "r");
   if( fp == NULL ) 
   {
      perror("打开文件时发生错误");
      return(-1);
   }
   while(!feof(fp)) 
   {
      c = getc (fp);
      /* 把 ! 替换为 + */
      if( c == '!' ) 
      {
         ungetc ('+', fp);
      }
      else 
      {
         ungetc(c, fp);
      }
      fgets(buffer, 255, fp);
      fputs(buffer, stdout);
   }
   return(0);
}

假设我们有一个文本文件 file.txt，它的内容如下。文件将作为实例中的输入：

this is xuebiancheng
!c standard library
!library functions and macros

让我们编译并运行上面的程序，这将产生以下结果：

this is xuebiancheng
+c standard library
+library functions and macros
+library functions and macros

C 库函数 - perror()

描述

C 库函数 void perror(const char *str) 把一个描述性错误消息输出到标准错误 stderr。首先输出字符串 str，后跟一个冒号，然后是一个空格。

声明

下面是 perror() 函数的声明。

void perror(const char *str)

参数

  • str -- 这是 C 字符串，包含了一个自定义消息，将显示在原本的错误消息之前。

返回值

该函数不返回任何值。

实例

下面的实例演示了 perror() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;

   /* 首先重命名文件 */
   rename("file.txt", "newfile.txt");

   /* 现在让我们尝试打开相同的文件 */
   fp = fopen("file.txt", "r");
   if( fp == NULL ) {
      perror("Error: ");
      return(-1);
   }
   fclose(fp);
      
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果，因为我们尝试打开一个不存在的文件：

Error: : No such file or directory