C语言笔记 10_文件读写&预处理器

文件读写

上一章我们讲解了 c 语言处理的标准输入和输出设备。本章我们将介绍 c 程序员如何创建、打开、关闭文本文件或二进制文件。

一个文件，无论它是文本文件还是二进制文件，都是代表了一系列的字节。c 语言不仅提供了访问顶层的函数，也提供了底层（os）调用来处理存储设备上的文件。本章将讲解文件管理的重要调用。

打开文件

您可以使用 fopen( ) 函数来创建一个新的文件或者打开一个已有的文件，这个调用会初始化类型 file 的一个对象，类型 file 包含了所有用来控制流的必要的信息。下面是这个函数调用的原型：

file *fopen( const char * filename, const char * mode );

在这里，filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个：

模式	描述
r	打开一个已有的文本文件，允许读取文件。
w	打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。
a	打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。
r+	打开一个文本文件，允许读写文件。
w+	打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。
a+	打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。

如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式：

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

关闭文件

为了关闭文件，请使用 fclose( ) 函数。函数的原型如下：

 int fclose( file *fp );

如果成功关闭文件，fclose( ) 函数返回零，如果关闭文件时发生错误，函数返回 eof。这个函数实际上，会清空缓冲区中的数据，关闭文件，并释放用于该文件的所有内存。eof 是一个定义在头文件 stdio.h 中的常量。

c 标准库提供了各种函数来按字符或者以固定长度字符串的形式读写文件。

写入文件

下面是把字符写入到流中的最简单的函数：

int fputc( int c, file *fp );

函数 fputc() 把参数 c 的字符值写入到 fp 所指向的输出流中。如果写入成功，它会返回写入的字符，如果发生错误，则会返回 eof。您可以使用下面的函数来把一个以 null 结尾的字符串写入到流中：

int fputs( const char *s, file *fp );

函数 fputs() 把字符串 s 写入到 fp 所指向的输出流中。如果写入成功，它会返回一个非负值，如果发生错误，则会返回 eof。您也可以使用

int fprintf(file *fp,const char *format, …)

函数来把一个字符串写入到文件中。尝试下面的实例：

注意：请确保您有可用的 tmp 目录，如果不存在该目录，则需要在您的计算机上先创建该目录。

/tmp 一般是 linux 系统上的临时目录，如果你在 windows 系统上运行，则需要修改为本地环境中已存在的目录，例如: c:\tmp、d:\tmp等。

#include <stdio.h>
 
int main()
{
   file *fp = null;
 
   fp = fopen("/tmp/test.txt", "w+");
   fprintf(fp, "this is testing for fprintf...\n");
   fputs("this is testing for fputs...\n", fp);
   fclose(fp);
}

当上面的代码被编译和执行时，它会在 /tmp 目录中创建一个新的文件 test.txt，并使用两个不同的函数写入两行。接下来让我们来读取这个文件。

读取文件

下面是从文件读取单个字符的最简单的函数：

int fgetc( file * fp );

fgetc() 函数从 fp 所指向的输入文件中读取一个字符。返回值是读取的字符，如果发生错误则返回 eof。

下面的函数允许您从流中读取一个字符串：

char *fgets( char *buf, int n, file *fp );

函数 fgets() 从 fp 所指向的输入流中读取 n - 1 个字符。它会把读取的字符串复制到缓冲区 buf，并在最后追加一个 null 字符来终止字符串。如果这个函数在读取最后一个字符之前就遇到一个换行符 '\n' 或文件的末尾 eof，则只会返回读取到的字符，包括换行符。

您也可以使用：

int fscanf(file *fp, const char *format, ...) 

fscanf函数从文件中读取字符串，但是在遇到第一个空格和换行符时，它会停止读取。

#include <stdio.h>
 
int main()
{
   file *fp = null;
   char buff[255];
 
   fp = fopen("/tmp/test.txt", "r");
   fscanf(fp, "%s", buff);
   printf("1: %s\n", buff );
 
   fgets(buff, 255, (file*)fp);
   printf("2: %s\n", buff );
   
   fgets(buff, 255, (file*)fp);
   printf("3: %s\n", buff );
   fclose(fp);
 
}

当上面的代码被编译和执行时，它会读取上一部分创建的文件，产生下列结果：

1: this
2: is testing for fprintf...

3: this is testing for fputs...

首先，fscanf() 方法只读取了 this，因为它在后边遇到了一个空格。其次，调用 fgets() 读取剩余的部分，直到行尾。最后，调用 fgets() 完整地读取第二行。

之所以会从上一次读取的位置继续读，是因为它会有一个指针指向上一次读取到那个位置，下一次再读取的时候直接从这个指针的位置开始，但前提是你没有在中途调用fclose函数来关闭文件。

二进制 i/o 函数

下面两个函数用于二进制输入和输出：

size_t fread(void *ptr, size_t size_of_elements, 
             size_t number_of_elements, file *a_file);
              
size_t fwrite(const void *ptr, size_t size_of_elements, 
             size_t number_of_elements, file *a_file);

这两个函数都是用于存储块的读写 - 通常是数组或结构体。

预处理器

c 预处理器不是编译器的组成部分，但是它是编译过程中一个单独的步骤。简言之，c 预处理器只不过是一个文本替换工具而已，它们会指示编译器在实际编译之前完成所需的预处理。我们将把 c 预处理器（c preprocessor）简写为 cpp。

所有的预处理器命令都是以井号（#）开头。它必须是第一个非空字符，为了增强可读性，预处理器指令应从第一列开始。下面列出了所有重要的预处理器指令：

指令	描述
#define	定义宏
#include	包含一个源代码文件
#undef	取消已定义的宏
#ifdef	如果宏已经定义，则返回真
#ifndef	如果宏没有定义，则返回真
#if	如果给定条件为真，则编译下面代码
#else	#if 的替代方案
#elif	如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码
#endif	结束一个 #if……#else 条件编译块
#error	当遇到标准错误时，输出错误消息
#pragma	使用标准化方法，向编译器发布特殊的命令到编译器中

预处理器实例

分析下面的实例来理解不同的指令。

#define max_array_length 20

这个指令告诉 cpp 把所有的 max_array_length 替换为 20。使用 #define 定义常量来增强可读性。

#include <stdio.h>
#include "myheader.h"

第一行指令告诉 cpp 从系统库中获取 stdio.h，并添加文本到当前的源文件中。

第二行告诉 cpp 从本地目录中获取 myheader.h，并添加内容到当前的源文件中。

#undef  file_size
#define file_size 42

这个指令告诉 cpp 取消已定义的 file_size，并定义它为 42。

#ifndef message
   #define message "you wish!"
#endif

这个指令告诉 cpp 只有当 message 未定义时，才定义 message。

#ifdef debug
   /* your debugging statements here */
#endif

这个指令告诉 cpp 如果定义了 debug，则执行处理语句。在编译时，如果您向 gcc 编译器传递了 -ddebug 开关量，这个指令就非常有用。它定义了 debug，您可以在编译期间随时开启或关闭调试。

预定义宏

ansi c 定义了许多宏。在编程中您可以使用这些宏，但是不能直接修改这些预定义的宏。

宏	描述
__date__	当前日期，一个以 "mmm dd yyyy" 格式表示的字符常量。
__time__	当前时间，一个以 "hh:mm:ss" 格式表示的字符常量。
__file__	这会包含当前文件名，一个字符串常量。
__line__	这会包含当前行号，一个十进制常量。
__stdc__	当编译器以 ansi 标准编译时，则定义为 1。

让我们来尝试下面的实例：

#include <stdio.h>

main()
{
   printf("file :%s\n", __file__ );
   printf("date :%s\n", __date__ );
   printf("time :%s\n", __time__ );
   printf("line :%d\n", __line__ );
   printf("ansi :%d\n", __stdc__ );

}

当上面的代码（在文件 test.c 中）被编译和执行时，它会产生下列结果：

file :test.c
date :dec 12 2019
time :16:34:13
line :8
ansi :1

预处理器运算符

c 预处理器提供了下列的运算符来帮助您创建宏：

宏延续运算符（）

一个宏通常写在一个单行上。但是如果宏太长，一个单行容纳不下，则使用宏延续运算符（）。例如：

#define  message_for(a, b)  \
    printf(#a " and " #b ": we love you!\n")

字符串常量化运算符（#）

在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（#）。在宏中使用的该运算符有一个特定的参数或参数列表。例如：

#include <stdio.h>

#define  message_for(a, b)  \
    printf(#a " and " #b ": we love you!\n")

int main(void)
{
   message_for(carole, debra);
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

carole and debra: we love you!

标记粘贴运算符（##）

宏定义内的标记粘贴运算符（##）会合并两个参数。它允许在宏定义中两个独立的标记被合并为一个标记。例如：

#include <stdio.h>

#define tokenpaster(n) printf ("token" #n " = %d", token##n)

int main(void)
{
   int token34 = 40;
   
   tokenpaster(34);
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

token34 = 40

这是怎么发生的，因为这个实例会从编译器产生下列的实际输出：

printf ("token34 = %d", token34);

这个实例演示了 token##n 会连接到 token34 中，在这里，我们使用了字符串常量化运算符（#）和标记粘贴运算符（##）。

defined() 运算符

预处理器 defined 运算符是用在常量表达式中的，用来确定一个标识符是否已经使用 #define 定义过。如果指定的标识符已定义，则值为真（非零）。如果指定的标识符未定义，则值为假（零）。下面的实例演示了 defined() 运算符的用法：

#include <stdio.h>

#if !defined (message)
   #define message "you wish!"
#endif

int main(void)
{
   printf("here is the message: %s\n", message);  
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

here is the message: you wish!

参数化的宏

cpp 一个强大的功能是可以使用参数化的宏来模拟函数。例如，下面的代码是计算一个数的平方：

int square(int x) {
   return x * x;
}

我们可以使用宏重写上面的代码，如下：

#define square(x) ((x) * (x))

在使用带有参数的宏之前，必须使用 #define 指令定义。参数列表是括在圆括号内，且必须紧跟在宏名称的后边。宏名称和左圆括号之间不允许有空格。例如：

#include <stdio.h>

#define max(x,y) ((x) > (y) ? (x) : (y))

int main(void)
{
   printf("max between 20 and 10 is %d\n", max(10, 20));  
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

max between 20 and 10 is 20

---

参考自：