【C语言】对文件的输入输出

💗个人主页💗
⭐个人专栏——C语言初步学习⭐
💫点击关注🤩一起学习C语言💯💫

导读

凡是用过计算机的人都不会对“文件”感到陌生，大多数人都接触过或使用过文件，例如：

1. 写一篇文章把它存放到磁盘上以文件形式保存；
2. 编写好一个程序，以文件形式保存在磁盘中；
3. 用数码相机照相，每一张照片就是一个文件。

需要时就从文件读取信息。在程序中使用文件之前应了解有关文件的基础知识。

1. 什么是文件

磁盘上的文件是文件。
但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。

1.1 程序文件

包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。这种文件的内容是程序代码。

1.2 数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行过程中输出到磁盘（或其他外部设备中）的数据，或在程序运行过程中供读入的数据。
如一批学生的成绩数据、货物交易的数据等。
本章讨论的是数据文件。
在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显
示器上。
其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。

1.3 数据流

输入输出是数据传送的过程，数据如流水一样从一处流向另一处，因此常将输入输出形象地称为流，即数据流。
流表示了信息从源到目的端的流动。

1.4 文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：（1）文件路径；（2）文件名主干；（3）文件后缀。
文件路径表示文件在外部存储设备中的位置。如：

为了方便起见，文件标识常被称为文件名。

2. 文件的分类

根据数据的组织形式，数据文件被称为文本文件或者二进制文件。

数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件，可以认为它就是存储在内存的数据的映像，所以也称之为映像文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文
本文件，也叫ASCII文件。

一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。
如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而
二进制形式输出，则在磁盘上只占4个字节。

3. 文件缓冲区

ANSIC 标准采用“缓冲文件系统”处理的数据文件，所谓缓冲文件系统是指系统自动地在内存中为程序中每一个正在使用的文件开辟一块“文件缓冲区”。
从内存向磁盘输出数据会先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根据C编译系统决定的。

这样做是为了节省存取实践，提高效率。
每一个文件在内存中只有一个缓冲区，在向文件输出数据时，他就作为输出缓冲区，在从文件输入数据时，它就作为输入缓冲区。

这里有个代码感兴趣的话可以在自己电脑上测试。

int main()
{
	FILE* pf = fopen("test.txt", "w");
	fputs("abcdef", pf);//先将代码放在输出缓冲区
	printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
	Sleep(10000);
	printf("刷新缓冲区\n");
	fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
   //注：fflush 在高版本的VS上不能使用了
	printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
	Sleep(10000);
	fclose(pf);
	//注：fclose在关闭文件的时候，也会刷新缓冲区
	pf = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

根据上面的代码，我们可以得出一个结论：

因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。
如果不做，可能导致读写文件的问题。

4. 文件的打开和关闭

4.1 文件指针

缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名
字，文件状态及文件当前的位置等）。
这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名FILE.
例如，一种C编译环境提供的stdio.h 头文件中有以下的文件类型声明：

typedef struct 
{
    short level;             //缓冲区“满”或“空”的程度
    unsigned flage;          //文件状态标志
    char fd;                 //文件描述符
    unsigned char hold;      //如缓冲区无内容不读取字符
    short bsize;             //缓冲区大小
    unsigned char* buffer;   //数据缓冲区的位置
    unsigned char* curp;     //文件位置标记指针当前的指向
    unsigned istemp;         //临时文件指示器
    short token;             //用于有效检查
}FILE;
1
2
3
4
5
6
7
8
9
10
11
12

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。
每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节。
一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。
下面我们可以创建一个FILE*的指针变量:

 FILE* pf;//文件指针变量
1

定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。

如果有n个文件，应设n个指针变量，分别指向n个FILE类型变量，以实现对n个文件的访问。

注意:
指向文件的指针变量并不是指向外部介质上的数据文件的开头，而是指向内存中的文件信息开头。如：

4.2 文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。

在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系。

ANSIC 规定使用fopen函数来打开文件，fclose来关闭文件。

//打开文件
FILE* fopen ( const char* filename, const char* mode );
 //关闭文件
int fclose ( FILE * stream );
1
2
3
4

使用文件方式

示例：

int main()
{
	FILE* pFile;
	//打开文件
	pFile = fopen("file.txt", "r");
	//文件操作
	if (pFile == NULL)
	{
		perror(" pFile");
		return 1;//如果打开失败，直接结束
	}
	//关闭文件
	fclose(pFile);
	pFile = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5. 文件的顺序读写

文件打开后就可以对它进行读写。在顺序读写中，先写入的数据存放在文件中前面的位置，后写入的数据存放在文件后面的位置。
一般情况下，在对字符文件进行顺序读写时，文件位置标记指向文件开头，这时如果对文件进行读的操作，就读第1个字符，然后文件位置标记向后移一个位置。以此类推，遇到文件尾结束。

5.1 向文件读写字符

5.1.1 fgetc输入字符

fgetc: 从fp指向的文件读入一个字符，读成功，带回所读的字符，失败则返回文件标志EOF (即-1)

int fgetc ( FILE * stream );
1

下面程序逐个字符读取名为myfile.txt并使用n变量来计算文件包含多少美元字符（$）。

int main()
{
    FILE* pFile;
    int c;
    int n = 0;
    pFile = fopen("myfile.txt", "r");
    if (pFile == NULL)
    {
        perror("Error opening file");
        return 1;
    }
    else
    {
        do 
        {
            c = fgetc(pFile);
            if (c == '$')
            {
                n++;
            }
        } while (c != EOF);
        fclose(pFile);
        pFile = NULL;
        printf("The file contains %d dollar sign characters ($).\n", n);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5.1.2 fputc输出字符

fputc: 把字符ch写到文件指针变量fp所指向的文件中，输出成功，返回值就是输出的字符，失败则返回EOF (即-1)

int fputc ( int character, FILE * stream );
1

该程序创建一个名为alphabet.txt的文件并将26个字母写入其中。

int main()
{
    FILE* pFile;
    char c = 0;
    pFile = fopen("alphabet.txt", "w");
    if (pFile != NULL) 
    {
        for (c = 'A'; c <= 'Z'; c++)
        {
            fputc(c, pFile);
        }
        fclose(pFile);
        pFile = NULL;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意，当前文件夹并没有alphabet.txt这个文件

下面我们来运行这个代码。

运行完成，我们发现alphabet.txt这个文件已经被创建，并且已写入内容。

5.2 向文件读写一个字符串

5.2.1 fgets读取字符串

fgets: 从fp指向的文件读入一个长度为（n-1）的字符串，存放到字符数组str中。
读成功，返回地址str，读失败则返回NULL。

char * fgets ( char * str, int num, FILE * stream );
1

该程序读取 myfile.txt文件的第一行或前 99 个字符（以先到者为准），并将它们打印在屏幕上。

int main()
{
    FILE* pFile;
    char mystring[100];

    pFile = fopen("myfile.txt", "r");
    if (pFile == NULL)
    {
        perror("Error opening file");
    }
    else 
    {
        if (fgets(mystring, 100, pFile) != NULL)
        {
            puts(mystring);
        }
        fclose(pFile);
        pFile = NULL;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.2.2 fputs输出字符串

fputs: 把str所指向的字符串写到文件指针变量fp所指向的文件中。
输出成功，返回0，输出失败，则返回非0值。

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

这个示例中，程序打开一个文件用于写入，并检查是否打开成功。然后，程序使用fputs将字符串’‘Hello, world!’'写入文件。最后，程序关闭文件。

int main() 
{
    FILE* fp;
    char str[] = "Hello, world!";

    fp = fopen("file.txt", "w");
    if (fp == NULL) 
    {
        printf("打开文件失败");
        return 1;
    }
    fputs(str, fp);
    printf("成功将字符串写入文件");
    fclose(fp);
    fp = NULL;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我们来检查字符串是否被写入文件中

5.3 用格式化的方式读写文本文件

5.3.1 fscanf和fprintf

fprintf(文件指针，格式字符串，输出表列)；
fscanf(文件指针，格式字符串，输入表列)；
fprintf(fp," %d, %f “, &i, &f);
fscanf(fp,” %d, %f ", &i, &f);

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

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

示例代码:

struct S
{
	float f;
	char c;
	int n;
};
int main()
{
	struct S s = { 3.14f,'w',100 };
	char arr[100] = { 0 };
	//将格式化的数据转换成字符串
	sprintf(arr,"%f-%c-%d\n", s.f, s.c, s.n);
	printf("%s\n", arr);
	struct S tmp = { 0 };
	//将字符串转换成格式化的数据
	sscanf(arr, "%f-%c-%n", &(tmp.f), &(tmp.c), &(tmp.n));
	printf("%f\n", tmp.f);
	printf("%c\n", tmp.c);
	printf("%d\n", tmp.n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.3.2 与scanf和printf的区别

scanf 是格式化的输入函数，针对的是标准输入流(键盘) printf 是格式化的输出函数，针对的是标准出流（屏幕）
scanf和printf是针对标准输入/输出流的格式化输入/输出函数 fscanf 是针对所有输入流(文件流、标准输入流)的格式化输出函数
fprintf 是针对所有输出流(文件流、标准输出流)的格式化输出函数

5.4 用二进制方式向文件读写一组数据

5.4.1 二进制读文件

fread: 从流中读取count个元素的数组，每个元素的大小为字节，并将它们存储在ptr指定的内存块中。

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
1

示例代码：

int main()
{
	int arr[10] = { 0 };
	FILE* pf = fopen("file.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//二进制的读文件
	fread(arr, sizeof(arr[0]), sizeof(arr) / sizeof(arr[0]), pf);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5.4.2 二进制写文件

fwrite: 将count个元素的数组从ptr指向的内存块写入流中的当前位置，每个元素的大小为字节。

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
1

创建一个名为myfile.bin的文件，并将缓冲区的内容存储到其中。为了简单起见，缓冲区包含char元素，但也可以包含任何其他类型。

int main()
{
	FILE* pFile;
	char buffer[] = { 'x' , 'y' , 'z' };
	pFile = fopen("myfile.bin", "wb");
	fwrite(buffer, sizeof(char), sizeof(buffer), pFile);
	fclose(pFile);
	return 0;
}
1
2
3
4
5
6
7
8
9

我们来检查下文件

6. 随机读写数据文件

对文件顺序读写比较容易理解，也容易操作，但有时效率不高，例如文件中有1000个数据，若只查第1000个数据，必须先逐个读入前面999个数据，才能读入第1000个数据。如果文件中存放一个城市几百万人的资料，若按照此方法查某一人的情况，等待的时间可能是不能忍受的。

随机访问不是按数据在文件中的物理位置进行读写，而是可以对任何位置上的数据进行访问， 显然这种方法比顺序访问效率高的多。

6.1 rewind

让文件指针的位置回到文件的起始位置

void rewind ( FILE * stream );
1

示例：

int main()
{
	int n = 0;
	FILE* pFile;
	char buffer[27];
	pFile = fopen("myfile.txt", "w+");
	for (n = 'A'; n <= 'Z'; n++)
	{
		fputc(n, pFile);//把二十六个字母写入文件
	}
	rewind(pFile);//使文件标记重新返回文件的开头
	fread(buffer, 1, 26, pFile);//读文件存到buffer
	fclose(pFile);
	pFile = NULL;
	buffer[26] = '\0';
	puts(buffer);//输出字符串
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.2 fseek

根据文件指针的位置和偏移量来定位文件指针。
fseek（文件类型指针，位移量，起始点）

int fseek ( FILE * stream, long int offset, int origin );
1

示例：

int main()
{
	FILE* pFile;
	pFile = fopen("example.txt", "wb");
	fputs("This is an apple.", pFile);//向文件写入内容
	fseek(pFile, 9, SEEK_SET);//设置起始点
	fputs(" sam", pFile);//再次写入内容
	fclose(pFile);
	pFile = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

6.3 ftell

返回文件指针相对于起始位置的偏移量

long int ftell ( FILE * stream );
1

示例：
来计算一个文件有多少字节

int main()
{
	FILE* pFile;
	long size;
	pFile = fopen("myfile.txt", "rb");
	if (pFile == NULL)
	{
		perror("Error opening file");
	}
	else
	{
		fseek(pFile, 0, SEEK_END);//改变偏移量,到末尾
		size = ftell(pFile);//返回偏移量
		fclose(pFile);
		pFile = NULL;
		printf("Size of myfile.txt: %ld bytes.\n", size);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7. 文件读写的出错检测

1. ferror函数
在调用各种输入输出函数（如putc,getc,fread和fwrite等）时，如果出现错误，除了函数返回值有所反映外，还可以用ferror函数检查，其调用形式为：

ferror(fp)

如果返回值为0（假），表示未出错；
如果返回值为一个非零值，表示出错。
2. clearerr函数
作用是使文件出错标志和文件结束标志未0。
假设，再调用一个输入输出函数时出现错误，ferror函数值为一个非零值，应立即调用clearerr(fp)，使clearerr(fp)的值便成0，以便再进行下一次的检测。