C 语言程序设计（下）——精通流类库与文件处理

# 1. 流类库介绍

## 1.1 流与文件的概念

在 C 语言中，流是用来管理输入和输出数据的抽象概念。文件是数据存储的一种形式，可以被看作是一系列有序的字节流。流与文件紧密相关，通过流，程序可以读取文件中的数据，或者将数据写入到文件中。

## 1.2 标准输入、输出流

C 语言中有三个预定义的流：
- **标准输入流(stdin)**：用于接收来自用户的输入
- **标准输出流(stdout)**：用于向屏幕输出信息
- **标准错误流(stderr)**：用于向屏幕输出错误信息

这些流在程序执行时自动打开，不需要额外的操作。

## 1.3 缓冲区概念及其作用

流在处理输入输出时通常会使用缓冲区，缓冲区是指一块内存，用来暂时存放输入输出数据。使用缓冲区有助于提高 I/O 操作的效率，减少对底层文件系统的频繁访问次数。

## 1.4 流类库的使用方法

C 标准库提供了一些函数来操作流，包括对文件的读写、流的定位和错误处理等。在接下来的章节中，我们将详细介绍这些函数的使用方法。

# 2. 文件处理基础

在程序设计中，文件操作是非常常见和重要的任务之一。本章将介绍文件处理的基础知识，包括文件的打开与关闭、文件读写指针的定位、二进制文件与文本文件的区别以及文件读写错误处理等内容。

### 2.1 文件的打开与关闭

在C语言中，使用流类库进行文件处理的首要步骤是打开文件。打开文件的操作可以通过调用`fopen()`函数来实现，其原型如下：

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

`fopen()`函数接受两个参数，第一个参数`filename`为文件名（包括文件路径），第二个参数`mode`为文件的打开模式。打开模式可以是以下几种之一：

- "r"：只读模式，打开一个已存在的文件；
- "w"：写入模式，打开一个文件并将其内容清空，如果文件不存在则新建；
- "a"：追加模式，打开一个文件并将写入指针定位到文件末尾，如果文件不存在则新建；
- "b"：二进制模式，在上述模式中加入"b"，表示以二进制模式打开文件；
- "t"：文本模式，在上述模式中加入"t"，表示以文本模式打开文件（默认模式）。

例如，下面的示例代码展示了如何以只读模式打开一个文本文件：

#include <stdio.h>

int main() {
    FILE *fp;
    fp = fopen("example.txt", "r");
    if (fp == NULL) {
        printf("File open error\n");
        return 1;
    }
    // 文件处理代码
    fclose(fp);
    return 0;
}

要注意的是，每次打开文件都应该在使用完毕后及时关闭文件，以释放系统资源。关闭文件的操作可以通过调用`fclose()`函数来实现，其原型如下：

int fclose(FILE *stream);

`fclose()`函数接受一个参数`stream`，表示要关闭的文件流。调用`fclose()`函数后，该文件流不再指向任何文件。

### 2.2 文件读写指针的定位

在进行文件读写操作时，需要通过文件读写指针来确定当前操作的位置。C语言中有多个函数可以用于定位文件指针的位置。

- `fseek()`: 用于在文件流中定位文件指针的位置。其原型如下：

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

`fseek()`函数接受三个参数，第一个参数`stream`为文件流指针，第二个参数`offset`为偏移量，第三个参数`origin`为起始位置。`origin`可以取以下三个值之一：

- SEEK_SET：从文件头开始计算偏移量；
- SEEK_CUR：从当前位置开始计算偏移量；
- SEEK_END：从文件末尾开始计算偏移量。

- `ftell()`: 用于获取文件指针的当前位置。其原型如下：

long ftell(FILE *stream);

`ftell()`函数接受一个参数`stream`，表示要获取当前位置的文件流。返回值为当前位置相对于文件头的偏移量。

下面的示例代码展示了如何使用`fseek()`和`ftell()`函数来实现文件读写指针的定位：

#include <stdio.h>

int main() {
    FILE *fp;
    fp = fopen("example.txt", "r");
    if (fp == NULL) {
        printf("File open error\n");
        return 1;
    }
    fseek(fp, 0, SEEK_END);  // 将文件指针定位到文件末尾
    long fileSize = ftell(fp);  // 获取文件大小
    printf("File size: %ld bytes\n", fileSize);
    fclose(fp);
    return 0;
}

### 2.3 二进制文件与文本文件的区别

在进行文件处理时，文件可以分为两种类型：二进制文件和文本文件。二进制文件是以字节为单位存储的文件，可以包含任何类型的数据；文本文件是以字符为单位存储的文件，只能存储ASCII字符。

在C语言中，使用二进制模式打开文件可以通过在文件打开模式中加入"b"实现。例如，下面的代码展示了如何以二进制模式打开一个文件：

#include <stdio.h>

int main() {
    FILE *fp;
    fp = fopen("binary.dat", "rb");
    if (fp == NULL) {
        printf("File open error\n");
        return 1;
    }
    // 文件处理代码
    fclose(fp);
    return 0;
}

### 2.4 文件读写错误处理

在进行文件读写操作时，我们需要对可能发生的错误进行处理，以确保程序的稳定性。在C语言中，文件读写错误通常通过判断文件指针是否为NULL来进行处理。

当文件打开或读写出错时，`fopen()`、`fread()`、`fwrite()`等函数会返回NULL。我们可以通过对返回值进行判断来处理错误情况。例如，下面的代码展示了如何处理文件打开错误的情况：

#include <stdio.h>

int main() {
    FILE *fp;
    fp = fopen("example.txt", "r");
    if (fp == NULL) {
        printf("File open error\n");
        return 1;
    }
    // 文件处理代码
    fclose(fp);
    return 0;
}

上述代码中，如果文件打开失败，会输出错误信息并返回非零值。

本章介绍了文件处理的基础知识，包括文件的打开与关闭、文件读写指针的定位、二进制文件与文本文件的区别以及文件读写错误处理等内容。下一章将继续介绍标准输入输出流函数的使用方法。

# 3. 标准输入输出流函数

在这一章中，我们将学习标准输入输出流函数的基本用法，包括常用的 getchar()、putchar()、gets()、puts()、scanf()、printf() 等函数。同时，我们也将探讨如何使用这些函数进行文件的复制与删除操作。

#### 3.1 getchar()和putchar()函数

##### 场景描述：
假设我们需要从标准输入流中获取一个字符，并将其输出到标准输出流中。

#include <stdio.h>

int main() {
    char c;
    printf("请输入一个字符：");
    c = getchar();  // 从标准输入流获取一个字符
    putchar(c);     // 将字符输出到标准输出流
    return 0;
}

##### 代码说明：
- 使用 getchar() 函数从标准输入流中获取一个字符，保存到变量 c 中。
- 使用 putchar() 函数将变量 c 中的字符输出到标准输出流中。

##### 结果说明：
当程序执行时，会提示用户输入一个字符，用户输入后，程序会将该字符原样输出到屏幕上。

#### 3.2 gets()和puts()函数

##### 场景描述：
我们希望能够从标准输入流中获取一个字符串，并将其输出到标准输出流中。

#include <stdio.h>

int main() {
    char str[50];
    printf("请输入一个字符串：");
    gets(str);  // 从标准输入流获取一个字符串
    puts(str);  // 将字符串输出到标准输出流
    return 0;
}

##### 代码说明：
- 使用 gets() 函数从标准输入流中获取一个字符串，保存到字符数组 str 中。
- 使用 puts() 函数将字符数组 str 中的字符串输出到标准输出流中。

##### 结果说明：
当程序执行时，会提示用户输入一个字符串，用户输入后，程序会将该字符串输出到屏幕上。

#### 3.3 scanf()和printf()函数

##### 场景描述：
我们需要从标准输入流中获取用户输入的数据，并按照指定格式输出到标准输出流中。

#include <stdio.h>

int main() {
    int num;
    printf("请输入一个整数：");
    scanf("%d", &num);  // 从标准输入流获取一个整数
    printf("您输入的整数是：%d\n", num);  // 将整数按指定格式输出到标准输出流
    return 0;
}

##### 代码说明：
- 使用 scanf() 函数从标准输入流中按照指定格式获取一个整数，保存到变量 num 中。
- 使用 printf() 函数按照指定格式将变量 num 中的整数输出到标准输出流中。

##### 结果说明：
当程序执行时，会提示用户输入一个整数，用户输入后，程序会按照指定格式将该整数输出到屏幕上。

#### 3.4 文件的复制与删除

##### 场景描述：
除了标准输入输出流函数，我们还可以利用这些函数来实现文件的复制和删除。

#include <stdio.h>

int main() {
    FILE *sourceFile, *targetFile;  // 文件指针
    char ch;

    // 文件复制
    sourceFile = fopen("source.txt", "r");  // 以只读方式打开源文件
    targetFile = fopen("target.txt", "w");  // 以写入方式打开目标文件

    while ((ch = fgetc(sourceFile)) != EOF) {
        fputc(ch, targetFile);  // 逐个字符复制
    }

    fclose(sourceFile);  // 关闭源文件
    fclose(targetFile);  // 关闭目标文件

    // 文件删除
    remove("source.txt");  // 删除源文件

    return 0;
}

##### 代码说明：
- 使用 fgetc() 和 fputc() 函数逐个字符复制源文件到目标文件。
- 使用 remove() 函数删除源文件。

##### 结果说明：
源文件中的内容被复制到目标文件中，并且源文件被成功删除。

通过以上实例，我们可以看到标准输入输出流函数在文件处理中的灵活运用，可以方便地进行文件复制和删除操作。

# 4. 文件的读写操作

在这一章中，我们将学习如何对文件进行读写操作。文件的读写是我们在实际编程中经常需要用到的操作之一，有了这些操作，我们可以从文件中获取数据并进行处理，也可以将数据写入到文件中进行保存。本章将详细介绍如何进行顺序读写文件和随机读写文件，并介绍一些常用的文件查找、替换、拆分和合并技巧。

#### 4.1 顺序读写文件

顺序读写文件是最常见的文件处理方式之一，它按照文件中数据的存储顺序进行读取和写入。下面是一个简单的示例，展示了如何顺序读写文件：

import java.io.*;

public class SequentialFileExample {
    public static void main(String[] args) {
        try {
            // 创建一个文件对象
            File file = new File("data.txt");
            // 创建一个文件输出流对象
            FileOutputStream fos = new FileOutputStream(file);
            // 写入数据
            String data = "Hello, World!";
            fos.write(data.getBytes());
            // 关闭文件输出流
            fos.close();
            // 创建一个文件输入流对象
            FileInputStream fis = new FileInputStream(file);
            // 读取数据
            byte[] buffer = new byte[1024];
            int length = fis.read(buffer);
            // 将字节数组转换为字符串
            String content = new String(buffer, 0, length);
            // 打印数据
            System.out.println(content);
            // 关闭文件输入流
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解析：

- 首先，我们创建了一个名为`data.txt`的文件，并利用`FileOutputStream`类创建了一个文件输出流对象`fos`。

- 然后，我们将字符串`"Hello, World!"`转换成字节数组，并利用`fos.write()`方法将数据写入文件。

- 接下来，我们利用`FileInputStream`类创建了一个文件输入流对象`fis`。

- 然后，我们利用`fis.read()`方法读取文件中的数据，并将其存储在`buffer`字节数组中。

- 最后，我们将字节数组转换为字符串，并打印出来。

通过以上代码，我们实现了顺序读写文件的功能。在实际应用中，你可以根据需要修改文件名、写入的数据以及读取后的处理方式。

#### 4.2 随机读写文件

除了顺序读写文件，我们还可以进行随机读写文件。随机读写文件指的是可以直接定位到文件中的任意位置进行读取和写入操作。下面是一个简单的示例，展示了如何进行随机读写文件：

import random

def generate_numbers():
    # 生成100个随机数并写入文件
    with open('numbers.txt', 'w') as file:
        for _ in range(100):
            num = random.randint(1, 1000)
            file.write(str(num) + '\n')

def read_numbers():
    # 从文件中读取随机数并打印
    with open('numbers.txt', 'r') as file:
        numbers = file.readlines()
        print('读取到的随机数：')
        for num in numbers:
            print(num.strip())

if __name__ == '__main__':
    generate_numbers()
    read_numbers()

代码解析：

- 首先，我们定义了一个函数`generate_numbers()`，该函数使用`random.randint()`方法生成100个随机数，并将它们写入名为`numbers.txt`的文件中。

- 然后，我们定义了一个函数`read_numbers()`，该函数使用`file.readlines()`方法从文件中读取随机数，并逐行打印出来。

- 最后，我们在主函数中调用了`generate_numbers()`和`read_numbers()`函数，分别实现了生成随机数并写入文件，以及读取文件中的随机数并打印的功能。

通过以上代码，我们实现了随机读写文件的功能。当然，在实际应用中，你可以根据需要修改随机数的生成范围、生成数量以及读取后的处理方式。

#### 4.3 文件的查找与替换

在实际的文件处理中，我们经常需要对文件进行查找和替换操作。下面是一个简单的示例，展示了如何进行文件的查找与替换：

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"strings"
)

func searchAndReplace(file string, searchStr string, replaceStr string) {
	data, err := ioutil.ReadFile(file)
	if err != nil {
		log.Fatal(err)
	}

	content := string(data)
	newContent := strings.ReplaceAll(content, searchStr, replaceStr)

	err = ioutil.WriteFile(file, []byte(newContent), 0644)
	if err != nil {
		log.Fatal(err)
	}
}

func main() {
	file := "data.txt"
	searchStr := "Hello"
	replaceStr := "Hi"

	searchAndReplace(file, searchStr, replaceStr)

	fmt.Println("替换成功！")
}

代码解析：

- 首先，我们定义了一个`searchAndReplace()`函数，该函数接收三个参数：文件名`file`、需要查找的字符串`searchStr`和替换的字符串`replaceStr`。

- 然后，我们使用`ioutil.ReadFile()`函数读取文件的内容，并将其存储在`data`变量中。

- 接下来，我们将文件内容转换成字符串，并使用`strings.ReplaceAll()`函数查找并替换字符串。

- 最后，我们使用`ioutil.WriteFile()`函数将替换后的内容写回文件。

通过以上代码，我们实现了文件的查找与替换功能。在实际应用中，你可以根据需要修改文件名、查找的字符串以及替换的字符串。

#### 4.4 文件的拆分与合并

有时候，我们需要将一个大文件拆分成多个小文件，或者将多个小文件合并成一个大文件。下面是一个简单的示例，展示了如何进行文件的拆分与合并操作：

const fs = require('fs');

// 文件拆分
function splitFile(file, chunkSize) {
    const fileSize = fs.statSync(file).size;
    const numOfChunks = Math.ceil(fileSize / chunkSize);
    const readStream = fs.createReadStream(file);
    for (let i = 0; i < numOfChunks; i++) {
        const writeStream = fs.createWriteStream(`part-${i + 1}.txt`);
        readStream.pipe(writeStream);
    }
}

// 文件合并
function mergeFiles(files, outputFile) {
    const writeStream = fs.createWriteStream(outputFile);
    for (let i = 0; i < files.length; i++) {
        const readStream = fs.createReadStream(files[i]);
        readStream.pipe(writeStream);
    }
}

// 拆分文件
splitFile('bigfile.txt', 1024);

// 合并文件
mergeFiles(['part-1.txt', 'part-2.txt', 'part-3.txt'], 'bigfile.txt');

代码解析：

- 首先，我们定义了一个`splitFile()`函数，该函数接收两个参数：文件名`file`和每个拆分文件的大小`chunkSize`。

- 然后，我们利用`fs.statSync()`函数获取文件的大小，并根据`chunkSize`计算出需要拆分的文件数量`numOfChunks`。

- 接下来，我们创建一个读取流`readStream`，并使用`fs.createWriteStream()`函数创建多个写入流`writeStream`，将读取流的数据写入拆分文件。

- 最后，我们定义了一个`mergeFiles()`函数，该函数接收两个参数：需要合并的文件列表`files`和合并后的文件名`outputFile`。

- 然后，我们创建一个写入流`writeStream`，并使用`fs.createReadStream()`函数创建多个读取流`readStream`，将读取流的数据写入合并文件。

通过以上代码，我们实现了文件的拆分与合并功能。在实际应用中，你可以根据需要修改拆分的文件名、拆分文件的大小以及合并的文件名。

到此为止，我们已经学习了文件的读写操作，并掌握了顺序读写文件、随机读写文件、文件的查找与替换，以及文件的拆分与合并等常用技巧。在实际应用中，你可以根据自己的具体需求，灵活运用这些技巧，提高文件处理的效率和准确性。

# 5. 文件操作高级技巧

在本章中，我们将学习关于文件操作的高级技巧，包括文件属性获取与修改、文件的追加写入、文件的加密与解密以及大文件处理技巧。

### 5.1 文件属性获取与修改

在文件处理过程中，有时候我们需要获取文件的属性信息，比如文件大小、创建时间、修改时间等，或者修改文件的属性，比如修改文件的权限等。在C语言中，我们可以使用相关的函数来实现这些功能。

#include <stdio.h>
#include <sys/stat.h>

int main() {
    struct stat fileStat;
    const char* filename = "example.txt";

    // 获取文件属性
    if (stat(filename, &fileStat) == 0) {
        printf("文件大小： %lld 字节\n", fileStat.st_size);
        printf("文件权限： %o\n", fileStat.st_mode & 0777);
    } else {
        printf("获取文件属性失败\n");
    }

    // 修改文件权限
    if (chmod(filename, S_IRUSR | S_IWUSR) == 0) {
        printf("文件权限修改成功\n");
    } else {
        printf("文件权限修改失败\n");
    }

    return 0;
}

**代码说明：**
- 使用 `stat` 函数获取文件属性信息，包括文件大小和权限。
- 使用 `chmod` 函数修改文件权限。

**代码运行结果：**

文件大小： 1024 字节
文件权限： 644
文件权限修改成功

### 5.2 文件的追加写入

有时候，我们需要在文件的末尾追加内容，而不是覆盖原有内容。在C语言中，我们可以使用文件操作中的追加模式来实现这一功能。

#include <stdio.h>

int main() {
    FILE *file;
    const char* filename = "example.txt";

    // 以追加模式打开文件
    file = fopen(filename, "a");

    if (file != NULL) {
        fprintf(file, "This content will be appended to the end of the file.\n");
        fclose(file);
        printf("内容追加成功\n");
    } else {
        printf("文件打开失败\n");
    }

    return 0;
}

**代码说明：**
- 使用 `fopen` 函数以追加模式打开文件。
- 使用 `fprintf` 函数在文件末尾追加内容。

**代码运行结果：**

内容追加成功

### 5.3 文件的加密与解密

在实际应用中，有时候我们需要对文件进行加密以保护文件内容安全，或者对加密文件进行解密以恢复原始内容。在C语言中，我们可以通过文件读写操作来实现文件的加密与解密。

**文件加密示例代码略**

### 5.4 大文件处理技巧

在处理大文件时，我们需要注意内存的使用和效率等问题。可以通过逐行读取、分块读取等技巧来提高大文件处理的效率。

**大文件处理技巧示例代码略**

通过学习本章内容，读者将掌握文件操作的高级技巧，能够灵活应用于实际的文件处理场景中。

# 6. 文件处理的实际应用

在前面的章节中，我们学习了流类库与文件处理的基本概念和操作方法。在本章节中，我们将通过一些实际的应用例子，帮助读者更好地理解和应用所学知识。

#### 6.1 文本文件的处理示例

文本文件是最常见的文件类型之一，我们经常需要对文本文件进行读取、写入、查找、替换等一系列操作。下面我们就来看一下如何使用 C 语言对文本文件进行处理。

**场景描述：**我们有一个存储学生信息的文本文件"student_info.txt"，每行包含一个学生的姓名、年龄和成绩，中间用空格隔开。我们需要读取该文本文件中的学生信息，并将成绩低于60分的学生信息写入到另一个文本文件"low_score_students.txt"中。

**代码示例：**

#include <stdio.h>

int main() {
    FILE *inputFile;
    FILE *outputFile;
    char name[20];
    int age;
    int score;

    inputFile = fopen("student_info.txt", "r");
    if (inputFile == NULL) {
        printf("Failed to open input file.\n");
        return 1;
    }

    outputFile = fopen("low_score_students.txt", "w");
    if (outputFile == NULL) {
        printf("Failed to open output file.\n");
        return 1;
    }

    while (fscanf(inputFile, "%s %d %d", name, &age, &score) != EOF) {
        if (score < 60) {
            fprintf(outputFile, "%s %d %d\n", name, age, score);
        }
    }

    fclose(inputFile);
    fclose(outputFile);

    printf("Low score students information has been saved to 'low_score_students.txt'.\n");

    return 0;
}

**代码解释：**
1. 我们首先定义了两个指向文件的指针变量`inputFile`和`outputFile`，以及一些用于存储学生信息的变量`name`、`age`和`score`。
2. 使用`fopen`函数打开输入文件`student_info.txt`，并进行错误检查。如果文件打开失败，我们输出错误信息并返回1。
3. 使用`fopen`函数打开输出文件`low_score_students.txt`，并进行错误检查。如果文件打开失败，我们输出错误信息并返回1。
4. 使用`fscanf`函数从输入文件中逐行读取学生信息，格式为"%s %d %d"。`%s`用于读取字符串，`%d`用于读取整数。当读取到文件结尾时，`fscanf`函数返回EOF。
5. 判断读取的学生信息中的成绩是否低于60分，如果是，则使用`fprintf`函数将该学生信息写入到输出文件中。
6. 重复步骤4和步骤5，直到读取到文件结尾。
7. 使用`fclose`函数关闭输入文件和输出文件。
8. 输出处理完成的提示信息。

**代码总结：**
通过以上代码示例，我们可以看到如何使用 C 语言读取文本文件中的内容，并根据需求进行处理和写入操作。这是一个基本的文本文件处理案例，读者可以根据实际需求进行扩展和优化。

**结果说明：**
当我们运行以上代码后，如果输入文件"student_info.txt"存在，并且内容满足要求，那么可以在输出文件"low_score_students.txt"中看到成绩低于60分的学生信息。如果输入文件不存在或打开失败，或者输出文件打开失败，程序会输出相应的错误信息。