• 文件介绍---C语言编程

    0 Preface/Foreword

    1 C文件概述

     文件（File）是程序设计中的一个重要的概念。所谓“文件”一般指存储在外部介质上数据的集合。一批数据是以文件的形式存放在外部介质（如磁盘）上。操作系统是以文件为单位对数据进行管理，也就是说，如果想找存在外部介质上的数据，必须先按文件名找到所指定的文件，然后再从该文件中读取数据。要向外部介质上存储数据也必须先建立一个文件（以文件名标识），才能向它输出数据。

    刚学习C语言编程时候，使用到的输入（Input）和输出（Output），是以终端（Terminal）为对象，即从终端键盘输入数据，运行结果输出到终端。从操作系统的角度看，与主机相连的输入输出设备都看做是一个文件。例如，终端键盘是输入文件，显示屏和打印机是输出文件。

    程序在运行时，经常需要将一些数据输出到磁盘上存放起来，方便后面需要时再从磁盘中输入到计算机内存。这里就需要使用到磁盘文件。

    C语言把文件看作是一个字符（字节）的序列（Sequence)，即由一个一个的字符（字节）数据顺序组成。根据数据的组织方式，可以分为ASCII文件和二进制文件。ASCII文件称为文本（text）文件，它的每一个字节放一个ASCII代码，代表一个字符。二进制文件是把内存中的数据按照其在内存中的存储形式原样输出到磁盘上存放。如果一个整数1000，在内存中占2个字节，如果按照ASCII码形式输出，则占4个字节，而按照二进制形式输出，在磁盘上只占2个字节。用ASCII码输出与字符一一对应，一个字节代表一个字符，因此方便对字符进行逐个处理，也方便输出字符；但一般占用存储空间多，而且要花费转换时间（二进制形式与ASCII码间的转换）。用二进制形式输出数值，可以节省外存空间和转换时间，但是一个字节并不对应一个字符，不能直接输出字符形式。一般中间结果数据需要暂时保存在外存上，以后又需要输入到内存的，常用二进制文件保存。

    一个C文件是一个字符流或二进制流。它把数据看作是一连串的字符（字节），而不考虑记录的界限，即C语言中的文件不是由记录（record）组成的。在C语言中对文件的存取是以字符（字节）为单位。输入输出的数据流的开始和结束仅受程序控制而不受物理符号（比如回车换行符）控制。即在输出时不会自动增加回车换行符以作为记录结束的标志，输入时不以回车换行符作为记录的间隔。把这种文件称为流式文件。C语言允许对文件存取一个字符，这样增加了处理的灵活性。

    C版本有两种对文件处理方法：一种是“缓冲文件系统”，一种叫“非缓冲文件系统”。

    缓冲文件系统：系统自动地在内存区为每一个正在使用的文件开辟一个缓冲区。从内存向磁盘输出数据必须先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘。如果从磁盘向内存读入数据，则一次从磁盘文件将一批数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区。（缓冲区的大小一般为512字节，具体与C版本有关）

    非缓冲文件系统：系统不自动开辟确定大小的缓冲区，而由程序为每个文件设定缓冲区。 

    在UNIX系统下，用缓冲文件系统来处理文本文件，用非缓冲文件系统处理二进制文件。ANSI C标准不采用非缓冲文件系统，只采用缓冲文件系统，即既用缓冲文件系统处理文本文件，也用它处理二进制文件，也就是将缓冲文件系统扩充为可处理二进制文件。

    C语言中，没有输入输出语句，对文件的读写都是用库函数来实现。ANSI规定了标准输入和输出函数，用它们对文件进行读写。

    博客中只介绍ANSI C规定的缓冲文件系统以及对它的读写。

    2. 文件类型指针

    缓冲文件系统中，关键的概念是“文件指针”。每个被使用的文件都在内存中开辟一个区，用来存放文件的有关信息（如文件的名字，文件状态及文件当前位置）。这些信息是保存在一个结构体变量中，该结构体类型是由系统定义的，取名为FILE。Turbo C在stdio.h文件中有以下的文件类型声明：

    typedef struct

    {

            short                 level; /* 缓冲区“满”和“空”的程度 */

            unsigned          flags; /* 文件状态标志 */

            char                  fd;     /* 文件描述符 */

            unsigned char  hold;  /* 如无缓冲区不读取字符 */

            short                 bsize;/* 缓冲区大小 */

            unsigned char  *buffer;/* 数据缓冲区的位置 */

            unsigned char  *curp;  /* 指针，当前的指向 */

            unsigned          istemp;/* 临时文件指示器 */

            short                 token; /* 用于有效性检查 */

    }FILE;

    3 文件打开和关闭

    和其他高级语言一样，对文件读写之前应该“打开”文件，在使用结束之后应该“关闭”文件。 

    3.1 打开文件（fopen函数）

    ANSI C规定了标准输入输出函数库，用fopen()函数实现打开文件。

    fopen的函数原型为： FILE *fopen(const char *filename, const char *mode);其功能是使用给定的模式 mode 打开 filename 所指向的文件。文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回 NULL，并把错误代码存在 error 中。该函数位于C 标准库中。以下关于使用文件方式的表格：

    文件使用方式

    含义

    “r”（只读）

    为输入打开一个文本文件

    “w”（只写）

    为输出打开一个文本文件

    “a”（追加）

    向文本文件尾添加数据

    “rb”（只读）

    为输入打开一个二进制文件

    “wb”（只写）

    为输出打开一个二进制文件

    “ab”（追加）

    向二进制文件尾添加数据

    “r+”（读写）

    为读写打开一个文本文件

    “w+”（读写）

    为读写建立一个新的文本文件

    “a+”（追加）

    为读写打开一个文本文件

    “rb+”（读写）

    为读写打开一个二进制文件

    “wb+”（读写）

    为读写建立一个新的二进制文件

    “ab+”（追加）

    为读写打开一个二进制文件

     以下几点内容需要注意：

    1. 用“r”方式打开的文件只能用于向计算机输入而不能用作向该文件输出数据，而且该文件应该已经存在。
    2. 用“w”方式打开的文件只能用于向该文件写数据（即输出文件），不能用来向计算机输入。如果原来不存在该文件，则在打开时新建立一个以指定的名字命名的文件。如果原来已经存在一个以该名字命名的文件，则在打开时将该文件删去，然后重新建立一个新文件。
    3. 如果希望向文件末尾添加新的数据（不希望删除原有数据），则应该用“a”方式打开。
    4. 在向计算机输入文本文件时，将回车换行符转换为一个换行符，在输出时把换行符转成为回车和换行连个字符。
    5. 在程序开始运行时，系统自动打开3个标准文件：标准输入，标准输出；标准出错输出。系统自动定义了3个文件指针stdin, stdout, stderr，分别指向终端输入，终端输出和标准出错输出（也从终端输出）。

    源码如下：

    1. #include 
    2.  
    3. //#define FILE_NAME "1.txt"
    4. #define FILE_NAME "2.txt"
    5. //#define FILE_OP_MODE "r"
    6. #define FILE_OP_MODE "a"
    7. //#define FILE_OP_MODE "wb+"
    8. int main (void)
    9. {
    10.         int ret = 0;
    11.         FILE *fp = NULL;
    12.         if (fp = fopen(FILE_NAME, FILE_OP_MODE)) {
    13.                 printf("file successfully open\n");
    14.         } else {
    15.  
    16.                 printf("file cannot open\n");
    17.         }
    18.         if (fp) {
    19.                 ret = fputc('a',fp);
    20.                 putchar('*');
    21.                 putchar('*');
    22.                 putchar('*');
    23.                 putchar('\n');
    24.                 printf("ret = %d\n", ret);
    25.         }
    26.         if (NULL != fp) {
    27.                 ret = fclose(fp);
    28.         }
    29.  
    30.         printf("ret = %d\n", ret);
    31.         return ret;
    32. }

    运行结果：

    3.2 关闭文件（fclose函数）

    在使用完一个文件后应该关闭它，以防止它再被误用。关闭就是使文件指针变量不指向该文件，也就是文件指针变量与文件脱钩，此后不能再通过该指针对原与其相关联的文件进行读写操作，除非再次打开，使该指针变量重新指向该文件。

    fclose是一个函数名，功能是关闭一个流。注意：使用fclose()函数就可以把缓冲区内最后剩余的数据输出到内核缓冲区，并释放文件指针和有关的缓冲区。
    函数原型：int fclose( FILE *fp );
    返回值：如果流成功关闭，fclose 返回 0，否则返回EOF（-1）。（如果流为NULL，而且程序可以继续执行，fclose设定error number给EINVAL，并返回EOF。）

    源码如下：

    #include

    #define FILE_NAME "1.txt"
    //#define FILE_NAME "2.txt"
    #define FILE_OP_MODE "r"
    int main (void)
    {
            int ret = 0;
            FILE *fp = NULL;
            if (fp = fopen(FILE_NAME, FILE_OP_MODE)) {
                    printf("file successfully open\n");
            } else {

                    printf("file cannot open\n");
            }
            if (NULL != fp) {
                    ret = fclose(fp);
            }

            printf("ret = %d\n", ret);
            return ret;
    }

    运行结果如下：

    4 文件的读写

    文件打开之后，就可以对它进行读写。

    4.1 fputc函数和fgetc函数（putc函数和getc函数） 

    4.1.1 fputc函数 

    把一个字符写到磁盘文件中。

    函数名称：写入字符文件函数fputc()

    函数格式：fputc (char c, File *fp)参数解释：fp为文件指针，它的值是执行fopen()打开文件时获得的。c为输入的字符量。

    返回值：在正常调用情况下，函数返回写入文件的字符的ASCII码值，出错时，返回EOF（-1）。当正确写入一个字符或一个字节的数据后，文件内部写指针会自动后移一个字节的位置。EOF是在头文件 stdio.h中定义的宏。 

    打印函数putchar其实是fputc的派生（derive）函数。

    #define putchar(c) fputc(c, stdout)

    源码如下：

    1. #include 
    2.  
    3. #define FILE_NAME "1.txt"
    4. //#define FILE_NAME "2.txt"
    5. //#define FILE_OP_MODE "r"
    6. #define FILE_OP_MODE "a"
    7. int main (void)
    8. {
    9.         int ret = 0;
    10.         FILE *fp = NULL;
    11.         if (fp = fopen(FILE_NAME, FILE_OP_MODE)) {
    12.                 printf("file successfully open\n");
    13.         } else {
    14.  
    15.                 printf("file cannot open\n");
    16.         }
    17.         if (fp) {
    18.                 ret = fputc('a',fp);
    19.                 putchar('*');
    20.                 putchar('*');
    21.                 putchar('*');
    22.                 putchar('\n');
    23.                 printf("ret = %d\n", ret);
    24.         }
    25.         if (NULL != fp) {
    26.                 ret = fclose(fp);
    27.         }
    28.  
    29.         printf("ret = %d\n", ret);
    30.         return ret;
    31. }

    运行结果： 

    4.1.2  fgetc函数

    从指定的文件读入一个字符，该文件必须是以读或读写方式打开的。

    fgetc是从文件指针stream指向的文件中读取一个字符，读取一个字节后，光标位置后移一个字节。格式：char fgetc(FILE *stream); 

     读成功，返回字符对应的ASCII码值，读错误或者文件已经到了末尾（文本文件），返回EOF（-1），因为字符的ASCII码值都是正数。

    ANSI C也可以用缓冲文件系统处理二进制文件，所以当返回fgetc的返回值为-1时，也不代表文件一定是到了文件末尾，体用feof函数来判断是否到了文件末尾。

    源码如下：

    1. #include 
    2.  
    3. #define FILE_NAME "2.txt"
    4. #define FILE_OP_MODE "r+"
    5. int main (void)
    6. {
    7.         int ret = 0;
    8.         FILE *fp = NULL;
    9.         if (fp = fopen(FILE_NAME, FILE_OP_MODE)) {
    10.                 printf("file successfully open\n");
    11.         } else {
    12.  
    13.                 printf("file cannot open\n");
    14.         }
    15.         if (fp) {
    16.                 putchar('*');
    17.                 putchar('*');
    18.                 putchar('*');
    19.                 putchar('\n');
    20.                 char ch = 0;
    21.                 ch = fgetc(fp);
    22.                 while (EOF != ch) {
    23.                         putchar(ch);
    24.                         ch = fgetc(fp);
    25.                 }
    26.         }
    27.         if (NULL != fp) {
    28.                 ret = fclose(fp);
    29.         }
    30.  
    31.         putchar('*');
    32.         putchar('*');
    33.         putchar('*');
    34.         putchar('\n');
    35.         printf("ret = %d\n", ret);
    36.         return ret;
    37. }
    38. ~

    运行结果：

    4.1.3 feof函数

    feof是C语言标准库函数，其原型在stdio.h中，其功能是检测流上的文件结束符，如果文件结束，则返回非0值，否则返回0（即，文件结束：返回非0值；文件未结束：返回0值）。 

    源码如下：

    1. #include 
    2.  
    3. #define FILE_NAME "2.txt"
    4. #define FILE_OP_MODE "r"
    5. int main (void)
    6. {
    7.         int ret = 0;
    8.         FILE *fp = NULL;
    9.         if (fp = fopen(FILE_NAME, FILE_OP_MODE)) {
    10.                 printf("file successfully open\n");
    11.         } else {
    12.  
    13.                 printf("file cannot open\n");
    14.         }
    15.         if (fp) {
    16.                 putchar('*');
    17.                 putchar('*');
    18.                 putchar('*');
    19.                 putchar('\n');
    20.                 char ch = 0;
    21.                 ch = fgetc(fp);
    22.                 //while (EOF != ch) {
    23.                 while (!feof(fp)) {
    24.                         printf("%d\n", ch);
    25.                         ch = fgetc(fp);
    26.                 }
    27.  
    28.         }
    29.         if (NULL != fp) {
    30.                 ret = fclose(fp);
    31.         }
    32.  
    33.         putchar('*');
    34.         putchar('*');
    35.         putchar('*');
    36.         putchar('\n');
    37.         printf("ret = %d\n", ret);
    38.         return ret;
    39. }
    40. ~

    运行结果：

    2.txt文件类型和内容如下：文件内容为2进制，不是ASCII编码。

     

    4.1.4 scanf

     原型：int scanf(const char * restrict format,...); 

    函数的第一个参数是格式字符串，它指定了输入的格式，并按照格式说明符解析输入对应位置的信息并存储于可变参数列表中对应的指针所指位置。每一个指针要求非空，并且与字符串中的格式符一一顺次对应。

    源码1：

    1. #include 
    2.  
    3. #define FILE_NAME "1.txt"
    4. #define FILE_OP_MODE "w+"
    5. int main (void)
    6. {
    7.         int ret = 0;
    8.         FILE *fp = NULL;
    9.         if (fp = fopen(FILE_NAME, FILE_OP_MODE)) {
    10.                 printf("file successfully open\n");
    11.  
    12.         } else {
    13.  
    14.                 printf("file cannot open\n");
    15.         }
    16.         if (fp) {
    17.                 char ch = 0;
    18.                 printf("Please input a character:\n");
    19.                 scanf("%c", &ch);
    20.                 getchar(); //to get the whitespace '\n'
    21.                 while ('#'!= ch) {
    22.                         fputc(ch, fp);
    23.                         printf("Please input a character:\n");
    24.                         scanf("%c", &ch);
    25.                         getchar(); // to get the whitespace '\n'
    26.                 }
    27.         }
    28.  
    29.         if (NULL != fp) {
    30.                 ret = fclose(fp);
    31.         }
    32.  
    33.         printf("ret = %d\n", ret);
    34.         return ret;
    35. }

    运行结果：

     NOTE：在输入字符或者字符串时，要特别注意以下两个信息残留问题

    1. 键盘缓冲区残留信息问题
    2. stdin残留信息

    源码2：

    1. #include 
    2.  
    3. #define FILE_NAME "1.txt"
    4. #define FILE_OP_MODE "w+"
    5. int main (void)
    6. {
    7.         int ret = 0;
    8.         FILE *fp = NULL;
    9.         if (fp = fopen(FILE_NAME, FILE_OP_MODE)) {
    10.                 printf("file successfully open\n");
    11.  
    12.         } else {
    13.  
    14.                 printf("file cannot open\n");
    15.         }
    16.         if (fp) {
    17.                 char ch = 0;
    18.                 printf("Please input a character:\n");
    19.                 ch = getchar();
    20.                 while ('#'!= ch) {
    21.                         fputc(ch, fp);
    22.                         printf("Please input a character:\n");
    23.                         ch = getchar();
    24.                 }
    25.                 fputc('\n', fp);
    26.         }
    27.  
    28.         if (NULL != fp) {
    29.                 ret = fclose(fp);
    30.         }
    31.  
    32.         printf("ret = %d\n", ret);
    33.         return ret;
    34. }

    运行结果：

     

    源码3：

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_W "w"
    5. #define FILE_OP_MODE_R "r"
    6. #define PARAM_LEN       3
    7. int main (int argc, char *argv[])
    8. {
    9.         int ret = 0;
    10.         FILE *fIn = NULL;
    11.         FILE *fOut = NULL;
    12.         char c=0;
    13.         if (PARAM_LEN != argc) {
    14.                 printf("Please enter input and output file name\n");
    15.                 exit(0);
    16.         }
    17.         // open input file
    18.         if (fIn = fopen(argv[1], FILE_OP_MODE_R)) {
    19.                 printf("Input file successfully open\n");
    20.  
    21.         } else {
    22.  
    23.                 printf("Input file cannot open\n");
    24.                 exit(0);
    25.         }
    26.         // open output file
    27.         if (fOut = fopen(argv[2], FILE_OP_MODE_W)) {
    28.                 printf("Output file successfully open\n");
    29.  
    30.         } else {
    31.  
    32.                 printf("Output file cannot open\n");
    33.                 exit(0);
    34.         }
    35.  
    36.         // copy input file to output file
    37.         //while (!feof(fIn)) {
    38.         while (EOF != (c=fgetc(fIn))) {
    39.                 fputc(c, fOut);
    40.                 //fputc(fgetc(fIn), fOut);
    41.         }
    42.  
    43.         //close files
    44.         fclose(fIn);
    45.         fclose(fOut);
    46.  
    47.         printf("ret = %d\n", ret);
    48.         return ret;
    49. }

    运行结果：

     

    源码4：

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_W "w"
    5. #define FILE_OP_MODE_R "r"
    6. #define PARAM_LEN       3
    7. int main (int argc, char *argv[])
    8. {
    9.         int ret = 0;
    10.         FILE *fIn = NULL;
    11.         FILE *fOut = NULL;
    12.         char c=0;
    13.         if (PARAM_LEN != argc) {
    14.                 printf("Please enter input and output file name\n");
    15.                 exit(0);
    16.         }
    17.         // open input file
    18.         if (fIn = fopen(argv[1], FILE_OP_MODE_R)) {
    19.                 printf("Input file successfully open\n");
    20.  
    21.         } else {
    22.  
    23.                 printf("Input file cannot open\n");
    24.                 exit(0);
    25.         }
    26.         // open output file
    27.         if (fOut = fopen(argv[2], FILE_OP_MODE_W)) {
    28.                 printf("Output file successfully open\n");
    29.  
    30.         } else {
    31.  
    32.                 printf("Output file cannot open\n");
    33.                 exit(0);
    34.         }
    35.  
    36.         // copy input file to output file
    37.         while (!feof(fIn)) {
    38.         //while (EOF != (c=fgetc(fIn))) {
    39.                 //fputc(c, fOut);
    40.                 fputc(fgetc(fIn), fOut);
    41.         }
    42.  
    43.         //close files
    44.         fclose(fIn);
    45.         fclose(fOut);
    46.  
    47.         printf("ret = %d\n", ret);
    48.         return ret;
    49. }

    运行结果：

    NOTE: ISO-8859 

    4.1.5 putchar

     #define putchar(c) fputc(c, stdout)

    4.1.6 getchar

    #define getchar() fgetc(stdin)

    4.1.7 getc

    #define getc(fp) fgetc(fp)

    4.1.8 putc

    #define putc(ch, fp) putc(ch, fp)

    4.1.9 fread

    从给定输入流stream读取最多count个对象到数组buffer中（相当于对每个对象调用size次fgetc），把buffer当作unsigned char数组并顺序保存结果。流的文件位置指示器前进读取的字节数。

    size_t fread( void *buffer, size_t size, size_t count, FILE *fp );

    参数解析：

    • buffer：指针，读入数据的存放地址
    • size：读入的字节数
    • count：需要读多少个size字节的数据项
    • fp：文件指针，读入数据的流文件

    源码：从磁盘中读出内存，并打印到屏幕

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_R "rb+"
    5. #define RECORD_STU_DATA "student.txt"
    6. #define AMOUNT          1
    7. #define WRITE_FAILED    0
    8.  
    9. typedef struct student{
    10.         int num;
    11.         char name[10];
    12.         int age;
    13.         char addr[20];
    14. }stu_t;
    15. stu_t stu[AMOUNT];
    16.  
    17. void load(void);
    18. void display_stu_info(void);
    19.  
    20. int main (int argc, char *argv[])
    21. {
    22.         int ret = 0;
    23.         load();
    24.         printf("ret = %d\n", ret);
    25.         return ret;
    26. }
    27.  
    28. void load(void)
    29. {
    30.         FILE *fp = NULL;
    31.         int cnt = 0;
    32.         printf("enter load function---->\n");
    33.         fp = fopen(RECORD_STU_DATA, FILE_OP_MODE_R);
    34.         if (NULL != fp) {
    35.                 printf("open file successfully\n");
    36.                 for (int i=0; i
    37.                         cnt = fread(&stu[i], sizeof(stu_t), 1, fp);
    38.                         if (WRITE_FAILED == cnt) {
    39.                                 printf("fail to read file\n");
    40.                                 break;
    41.                         }
    42.                 }
    43.  
    44.         } else {
    45.                 return;
    46.         }
    47.         display_stu_info();
    48.         fclose(fp);
    49. }
    50.  
    51. void display_stu_info(void)
    52. {
    53.         printf("enter display function---->\n");
    54.  
    55.         for (int i=0; i
    56.                 printf("stu[%d].num:%d, stu[%d].name:%s, stu[%d].age:%d, stu[%d].addr:%s\n", i, stu[i].num, i, stu[i].name, i, stu[i].age, i, stu[i].addr);
    57.         }
    58. }

    运行结果：

    4.1.10 fwrite

    fwrite() 是 C 语言标准库中的一个文件处理函数，功能是向指定的文件中写入若干数据块，如成功执行则返回实际写入的数据块数目。该函数以二进制形式对文件进行操作，不局限于文本文件。

    size_t fwrite( void *buffer, size_t size, size_t count, FILE *fp );

    参数解析：

    • buffer：指针，输出数据的存放地址
    • size：写数据的字节数
    • count：需要写多少个size字节的数据项
    • fp：文件指针，输出数据的流文件

    源码：从键盘中输入学生信息，并将数据保存到磁盘中

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_W "wb+"
    5. #define RECORD_STU_DATA "student.txt"
    6. #define AMOUNT          1
    7. #define WRITE_FAILED    0
    8.  
    9. typedef struct student{
    10.         int num;
    11.         char name[10];
    12.         int age;
    13.         char addr[20];
    14. }stu_t;
    15. stu_t stu[AMOUNT];
    16.  
    17. void save(void);
    18. int main (int argc, char *argv[])
    19. {
    20.         int ret = 0;
    21.         for (int i=0; i
    22.                 printf("Please input student's informations as below:\n");
    23.  
    24.                 // input student's number
    25.                 printf("Enter student number->\n");
    26.                 scanf("%d", &stu[i].num);
    27.                 printf("stu[%d].num = %d\n", i, stu[i].num);
    28.  
    29.  
    30.                 // input student's name
    31.                 printf("Enter student name->\n");
    32.                 scanf("%s", stu[i].name);
    33.                 printf("stu[%d].name = %s\n", i, stu[i].name);
    34.  
    35.                 // input student's age
    36.                 printf("Enter student age->\n");
    37.                 scanf("%d", &stu[i].age);
    38.                 printf("stu[%d].age = %d\n", i, stu[i].age);
    39.  
    40.                 // input student's address
    41.                 printf("Enter student address->\n");
    42.                 scanf("%s", stu[i].addr);
    43.                 printf("stu[%d].addr = %s\n", i, stu[i].addr);
    44.         }
    45.         save();
    46.         printf("ret = %d\n", ret);
    47.         return ret;
    48. }
    49. void save(void)
    50. {
    51.         FILE *fp = NULL;
    52.         int cnt = 0;
    53.         printf("enter save function---->\n");
    54.         fp = fopen(RECORD_STU_DATA, FILE_OP_MODE_W);
    55.         if (NULL != fp) {
    56.                 printf("open file successfully\n");
    57.                 for (int i=0; i
    58.                         cnt = fwrite(&stu[i], sizeof(stu_t), 1, fp);
    59.                         if (WRITE_FAILED == cnt) {
    60.                                 printf("fail to write file\n");
    61.                                 break;
    62.                         }
    63.                 }
    64.  
    65.         } else {
    66.                 return;
    67.         }
    68.         fclose(fp);
    69. }

    运行结果：

    4.1.11 fprintf

    printf是C/C++中的一个格式化库函数，位于头文件;中，其作用是格式化输出到一个流文件中；函数原型为int fprintf( FILE *stream, const char *format, [ argument ]...)，fprintf()函数根据指定的格式(format)，向输出流(stream)写入数据(argument)。

    返回值：输出的字符数

    源码：

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_R "wb+"
    5. #define RECORD_STU_DATA "test.txt"
    6.  
    7. int main (int argc, char *argv[])
    8. {
    9.         int ret = 0;
    10.         int cnt = 0;
    11.         FILE *fp = fopen(RECORD_STU_DATA, FILE_OP_MODE_R);
    12.         if (NULL == fp) {
    13.                 printf("open failed\n");
    14.                 return -1;
    15.         }
    16.  
    17.         cnt = fprintf(fp, "%d %s\n",1, "123456");
    18.         fclose(fp);
    19.         printf("cnt = %d\n", cnt);
    20.         printf("ret = %d\n", ret);
    21.         return ret;
    22. }

    运行结果：

    4.1.12 fscanf 

    4.1.13 fputs

    功能：将字符串输出到指定的文件中。

    参数：<文件指针>，<字符串>

    源代码如下：

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_W "w"
    5. #define FILE_OP_MODE_R "r"
    6. int main (int argc, char *argv[])
    7. {
    8.         int ret = 0;
    9.         FILE *fp = fopen(argv[1], FILE_OP_MODE_W);
    10.  
    11.         fputs("Hello World!", fp);
    12.         fclose(fp);
    13.         printf("ret = %d\n", ret);
    14.         return ret;
    15. }

     运行结果：

    4.1.14 fgets

    功能：从指定文件中获取字符串

    参数：<缓冲区>，<缓冲区长度>，<文件指针>

    返回值：返回指向缓冲区首地址

    源代码：

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_W "w"
    5. #define FILE_OP_MODE_R "r"
    6. #define LEN 20
    7. int main (int argc, char *argv[])
    8. {
    9.         int ret = 0;
    10.         char buf[20];
    11.         FILE *fp = fopen(argv[1], FILE_OP_MODE_R);
    12.         char *p = NULL;
    13.  
    14.         p = fgets(buf, sizeof(buf), fp);
    15.         printf("%s", buf);
    16.         printf("%s", p);
    17.         fclose(fp);
    18.         printf("ret = %d\n", ret);
    19.         return ret;
    20. }

    运行结果：

    4.1.15 putw

    该接口用于向指定的文件流中输出一个字大小的数据，默认情况下，该接口在C库中都有实现。

    源代码：

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_W "w"
    5. #define FILE_OP_MODE_R "r"
    6.  
    7. int rewrite_putw(int val, FILE *p);
    8.  
    9. int main (int argc, char *argv[])
    10. {
    11.         int ret = 0;
    12.         FILE *fp = fopen(argv[1], FILE_OP_MODE_W);
    13.  
    14.         int val = 2;
    15. //      putw(val, fp);
    16.         rewrite_putw(val, fp);
    17.         fclose(fp);
    18.         printf("ret = %d\n", ret);
    19.         return ret;
    20. }
    21.  
    22.  
    23. int rewrite_putw(int val, FILE *p)
    24. {
    25.         int ret = 0;
    26.         char *cp = (char *)&val;
    27.         int cnt = 0;
    28.         while (cnt < sizeof(int)) {
    29.                 fputc(*cp, p);
    30.                 cp++;
    31.                 cnt++;
    32.         }
    33.         return ret;
    34. }

    运行结果：

    4.1.16 getw

    从打开的文件流中获取一个字大小的数据。

    源代码：

    1. #include 
    2. #include 
    3.  
    4. #define FILE_OP_MODE_W "w"
    5. #define FILE_OP_MODE_R "r"
    6.  
    7. int rewrite_getw(FILE *p);
    8.  
    9. int main (int argc, char *argv[])
    10. {
    11.         int ret = 0;
    12.         FILE *fp = fopen(argv[1], FILE_OP_MODE_R);
    13.  
    14.         //ret = getw(fp);
    15.         ret = rewrite_getw(fp);
    16.         fclose(fp);
    17.         printf("ret = %d\n", ret);
    18.         return ret;
    19. }
    20.  
    21.  
    22. int rewrite_getw(FILE *p)
    23. {
    24.         int getVal = 0;
    25.         char *cp = (char *)&getVal;
    26.         int cnt = 0;
    27.         while (cnt < sizeof(int)) {
    28.                 *cp =fgetc(p);
    29.                 cp++;
    30.                 cnt++;
    31.         }
    32.         return getVal;
    33.  
    34. }

    运行结果：

    5 文件的定位

    6 出错的检测

    7 文件输入输出小结

  • 相关阅读:
    ​旅行季《乡村振兴战略下传统村落文化旅游设计》许少辉八一著作想象和世界一样宽广
    C++ 多态
    Knife4j使用教程（一） -- 在不同版本SpringBoot，选用不同的Knife4j相关的jar包
    【概率论】期中复习笔记（下）：大数定律与中心极限定理
    DAY17-深度学习100例-卷积神经网络（CNN）识别眼睛状态
    HFSS笔记——优化设计optimetrics
    Springboot开发系统记录操作日志
    LM324的输出VOL与IOL你注意过吗？
    医疗图像自动轮廓勾画
    Flutter入门教程（二）开发环境搭建
  • 原文地址：https://blog.csdn.net/yanlaifan/article/details/133820668