【ARM 嵌入式 C 文件操作系列 20.1 -- 从 A文件的 n 行开始 拷贝 m行到 B文件中】

已于 2024-04-06 09:34:43 修改
阅读量352 收藏 2
点赞数 9
CC 4.0 BY-SA版权
分类专栏： 【嵌入式 C 常用算法专栏】 文章标签： c语言 算法 开发语言
于 2024-04-03 19:28:07 首次发布
主公讲ARM
本文链接：https://blog.youkuaiyun.com/sinat_32960911/article/details/137294155
文章详细介绍了如何使用C语言实现文件行拷贝功能，包括从指定行开始、按固定字符长度拷贝、以及追加模式下拷贝。展示了file_copy_lines、copy_lines、copy_fixed_length_lines和append_lines_from_file等函数的代码及其工作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


请阅读【嵌入式开发学习必备专栏 】

文章目录

文件行拷贝

从文件 a 中从第 n 行开始拷贝 m 行到文件 b 的函数，将需要使用标准库函数来读取和写入文件。以下是一个 file_copy_lines 函数实现：

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

void file_copy_lines(const char *src_filename, const char *dest_filename, int n, int m) 
{
    FILE *src = fopen(src_filename, "r");
    FILE *dest = fopen(dest_filename, "w");
    
    if (src == NULL || dest == NULL) {
        fprintf(stderr, "Error opening files.\n");
        exit(EXIT_FAILURE);
    }
    
    char buffer[1024]; // 假设一行最大长度为 1023 字符
    int current_line = 0;
    
    // 跳过前 n-1 行
    while (current_line < n - 1 && fgets(buffer, sizeof(buffer), src) != NULL) {
        current_line++;
    }
   
    // 拷贝 m 行到目标文件
    while (current_line < n + m - 1 && fgets(buffer, sizeof(buffer), src) != NULL) {
        fputs(buffer, dest);
        current_line++;
    }
    fclose(src);
    fclose(dest);
}

int main(void) 
{
    const char *src_filename = "a.txt";
    const char *dest_filename = "b.txt";
    int start_line = 2; // 从第二行开始拷贝
    int num_lines = 3; // 拷贝三行
    
    file_copy_lines(src_filename, dest_filename, start_line, num_lines);
   
    return 0;
}

这个 file_copy_lines 函数接收四个参数：源文件名 src_filename，目标文件名 dest_filename，起始行号 n，以及要拷贝的行数 m。它首先尝试打开源文件和目标文件，并在无法打开时报错退出。

函数使用 fgets 来读取每一行，利用 buffer 数组作为中介存储每行的内容。如果当前行号小于 n-1，它会继续读取；当行号达到 n-1 时，它开始将内容写入目标文件，直到拷贝了 m 行内容。最后，函数关闭了两个打开的文件。

这个例子假设了每行的最大长度为 1023 字符（加上一个空终止符，总共 1024 字符）。如果预计有更长的行，需要根据需要调整 buffer 的大小。此外，fgets 会读取换行符并将其包含在结果字符串中，因此整行内容（包括换行符）都会被写入目标文件。如果源文件的最后一行长度超过 buffer 的大小，fgets 可能不会一次性读取完整行，可能需要特别处理。

根据行数大小设定拷贝方法

从文件 a.txt 中拷贝指定行数的内容，如果 lines 小于等于 100，它将一次性拷贝所有行；如果 lines 大于 100，它将每次拷贝 100 行，直到拷贝完 lines 行。

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

void copy_lines(const char *src_filename, int start_line, int lines) 
{
    FILE *src = fopen(src_filename, "r");
    if (src == NULL) {
        perror("Error opening source file");
        exit(EXIT_FAILURE);
    }
    FILE *dest = fopen("b.txt", "w");
    if (dest == NULL) {
        perror("Error opening destination file");
        fclose(src); // 关闭已经打开的源文件
        exit(EXIT_FAILURE);
    }
    char buffer[1024]; // 假设一行最大长度为 1023 字符
    int current_line = 0;
    int lines_to_copy = lines > 100 ? 100 : lines; // 每次最多拷贝 100 行
    while (current_line < start_line - 1 && fgets(buffer, sizeof(buffer), src) != NULL) {
        current_line++; // 跳过前 start_line-1 行
    }
    while (lines > 0 && fgets(buffer, sizeof(buffer), src) != NULL) {
        fputs(buffer, dest); // 拷贝一行到目标文件
        lines--;
        current_line++;
        if (current_line % 100 == 0 && lines > 0) {
            fclose(dest); // 关闭当前的目标文件，每 100 行后重新打开
            dest = fopen("b.txt", "a");
            if (dest == NULL) {
                perror("Error reopening destination file");
                fclose(src);
                exit(EXIT_FAILURE);
            }
            lines_to_copy = lines > 100 ? 100 : lines; // 更新剩余行数
        }
    }
    fclose(src);
    fclose(dest);
}
int main(void) 
{
    const char *src_filename = "a.txt";
    int start_line = 1; // 从第一行开始拷贝
    int num_lines = 250; // 拷贝 250 行
    copy_lines(src_filename, start_line, num_lines);
    return 0;
}

这个 copy_lines 函数会根据 lines 的值来决定拷贝行为。它首先尝试打开源文件 a.txt 和目标文件 b.txt。如果遇到错误，它会打印错误信息并退出程序。

函数使用 fgets 读取每一行，并使用 fputs 将这些行写入目标文件。为了拷贝从特定行开始的内容，它首先跳过 start_line - 1 行。然后开始拷贝，如果行数超过 100，它将关闭目标文件，然后重新以追加模式打开，从而每次最多拷贝 100 行，直到完成 lines 行的拷贝。

请确保在运行程序前，源文件 a.txt 存在于同一目录中，并且有足够的行供程序读取。如果源文件的某一行超出了缓冲区 buffer 的大小（在本例中为 1024 字符），fgets 可能会分多次读取该行，可能需要调整缓冲区大小或进行特殊处理以确保每行都被完整读取。

拷贝每行固定字符个数的方式

下面是一个 C 语言函数的实现，该函数打开文件 a.txt，定位到第 n 行，然后从第 n 行开始复制 m 行数据，每行有固定的 32 个字符：

#include <stdio.h>
#include <stdlib.h>
void copy_fixed_length_lines(const char *src_filename, const char *dest_filename, int n, int m) 
{
    FILE *src = fopen(src_filename, "r");
    if (src == NULL) {
        perror("Error opening source file");
        exit(EXIT_FAILURE);
    }
    FILE *dest = fopen(dest_filename, "w");
    if (dest == NULL) {
        perror("Error opening destination file");
        fclose(src); // 关闭已经打开的源文件
        exit(EXIT_FAILURE);
    }
    int current_line = 0;
    int copied_lines = 0;
    char buffer[33]; // 32个字符加上终结符 '\0'
    // 跳过前 n-1 行
    while (current_line < n - 1 && fgets(buffer, sizeof(buffer), src) != NULL) {
        current_line++;
    }
    // 从第 n 行开始复制 m 行数据
    while (copied_lines < m && fgets(buffer, sizeof(buffer), src) != NULL) {
        // 如果读到的行不足32个字符，则使用空格填充
        buffer[32] = '\0'; // 确保字符串的结束
        if (strlen(buffer) < 32) {
            memset(buffer + strlen(buffer) - 1, ' ', 32 - strlen(buffer));
        }
        fprintf(dest, "%.32s\n", buffer); // 将缓冲区的前32个字符写入目标文件
        copied_lines++;
    }
    fclose(src);
    fclose(dest);
}

int main(void) 
{
    const char *src_filename = "a.txt";
    const char *dest_filename = "b.txt";
    int start_line = 3; // 从第三行开始复制
    int num_lines = 5; // 复制五行
    copy_fixed_length_lines(src_filename, dest_filename, start_line, num_lines);
    return 0;
}

这个 copy_fixed_length_lines 函数使用 fopen 分别以读模式 ("r") 打开源文件 a.txt 和写模式 ("w") 打开目标文件 b.txt。如果源文件或目标文件打开失败，函数打印错误信息并退出。

函数首先跳过 n - 1 行，然后开始复制 m 行数据。每次从文件中读取的内容使用 fgets 存储到 buffer 中，该缓冲区大小为 33 字节，为了确保存储 32 个字符加上一个 null 终止符。由于 fgets 会读取并包含换行符（如果有的话），所以如果读取的行不足 32 个字符，使用 memset 在行末填充空格，直到达到 32 个字符。然后，使用 fprintf 写入刚好 32 个字符到目标文件，并追加一个换行符。

如果源文件的任何行长度超过了 32 个字符，此函数将只复制每行的前 32 个字符。如果源文件的任何行长度不足 32 个字符，将用空格填充至 32 个字符。如果源文件中的行数少于 n，或者从第 n 行开始的行数少于 m，那么函数只复制可用的行数。

最后，函数关闭了打开的文件。在实际使用中，可能需要调整 buffer 的大小或函数的逻辑来匹配不同长度的行或不同的复制策略。

追加方式拷贝

下面是一个 C 语言函数的实现，该函数从文件 a.txt 中指定的 start_line 行开始，复制 lines 行，并以追加模式写入文件 b.txt：

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

void append_lines_from_file(const char *src_filename, const char *dest_filename, int start_line, int lines) 
{
    FILE *src = fopen(src_filename, "r");
    if (src == NULL) {
        perror("Error opening source file");
        exit(EXIT_FAILURE);
    }
   
    FILE *dest = fopen(dest_filename, "a"); // 打开目标文件以追加模式
    if (dest == NULL) {
        perror("Error opening destination file");
        fclose(src); // 关闭已经打开的源文件
        exit(EXIT_FAILURE);
    }
   
    char buffer[1024]; // 假设一行最大长度为 1023 字符
    int current_line = 0;
    
    // 跳过前 start_line - 1 行
    while (current_line < start_line - 1 && fgets(buffer, sizeof(buffer), src) != NULL) {
        current_line++;
    }
  
    // 从 start_line 行开始复制 lines 行
    while (lines > 0 && fgets(buffer, sizeof(buffer), src) != NULL) {
        fputs(buffer, dest); // 将当前行写入目标文件
        lines--;
    }
    fclose(src);
    fclose(dest);
}

int main(void) 
{
    const char *src_filename = "a.txt";
    const char *dest_filename = "b.txt";
    int start_line = 1; // 从第一行开始复制
    int num_lines = 5; // 复制五行
   
    append_lines_from_file(src_filename, dest_filename, start_line, num_lines);
   
    return 0;
}

在这个函数 append_lines_from_file 中，使用 fopen 函数以读模式 ("r") 打开源文件 a.txt 和以追加模式 ("a") 打开目标文件 b.txt。追加模式确保写入目标文件的内容不会覆盖现有内容，而是添加到文件末尾。

接着，读取源文件 src 直到到达 start_line。然后开始复制 lines 行到目标文件 dest。这是通过使用 fgets 读取每一行并用 fputs 写入目标文件实现的。

使用了一个缓冲区 buffer，它假设每一行的最大长度为 1023 字符加上一个 null 终止符。如果你预计会有更长的行，你将
需要增加 buffer 的大小。

最后，用 fclose 关闭源文件和目标文件的文件指针。如果在打开文件时发生错误，使用 perror 打印错误信息并退出程序。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

主公讲 ARM

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值