Linux&C语言简单实现双/3进程拷贝-文件IO实现

最新推荐文章于 2023-02-01 19:25:09 发布
最新推荐文章于 2023-02-01 19:25:09 发布
阅读量798 收藏 7
点赞数
分类专栏： Linux&C 文章标签： linux c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47355554/article/details/124524214
版权

1. 基于C语言实现，文件IO练习

2.代码实现

2.1(命令行指定)使用父子进程拷贝同一个文件，父进程拷贝前半部分，子进程拷贝后半部分

#include <stdio.h> // Shift  +  Alt  + F     实现代码的对齐；
/* fork函数的头文件*/
#include <sys/types.h>
#include <unistd.h>
/* open函数的头文件---文件IO*/
//#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
/*wait函数的头文件*/
#include <wait.h>

/*exit*/
#include <stdlib.h>

/* lseek函数的头文件---文件IO*/
//#include <sys/types.h>
//#include <unistd.h>

/*计算要拷贝文件字符个数*/
int get_src_file_len(const char *srcfile,const char * destfile)
{
    int sfd,dfd;
    int len=0;
    //打开目标要拷贝的文件
    if((sfd = open(srcfile,O_RDONLY))==-1){//只读
        printf("open srcfile error");
    }
    //打开存放拷贝的文件
    if((dfd = open(destfile,O_RDWR|O_CREAT|O_TRUNC,0664))==-1){
                            //读写| 创建文件| 清空文件
        printf("open destfile error");
    }
    //读取目标要拷贝的文件的字节数
    len = lseek(sfd,0,SEEK_END);

    close(sfd);//关闭文件
    close(dfd);
    return len;
}
/*父子进程拷贝文件*/
int copy_file(const char *srcfile,const char * destfile,int start,int len)
{
    int sfd,dfd;
    char buf[10] = {0};
    int ret=0;
    //记录已经读取字节数
    int i = 0;
    //打开目标要拷贝的文件
    if((sfd = open(srcfile,O_RDONLY))==-1){//只读
        printf("open srcfile error");
    }
    //打开存放拷贝的文件
    if((dfd = open(destfile,O_RDWR))==-1){//读写
        printf("open destfile error");
    }
    //光标从头开始，移动start
    lseek(sfd,start,SEEK_SET);
    lseek(dfd,start,SEEK_SET);

    while(1){
        ret = read(sfd,buf,sizeof(buf));

        i+=ret;//记录已经读取字节数
        //结尾||读多了
        if(ret==0 || i>len) {
           write(dfd,buf,ret-(i-len)); 
           break;
        }  
        write(dfd,buf,ret); 
    }
    close(sfd);
    close(dfd);
    return 0;
}
int main(int argc,const char * argv[])
{
    //检测命令行 3个参数
    if(argc != 3){
        fprintf(stderr,"input error,try again\n");
        fprintf(stderr,"usage:./a.out srcfile,destfile\n");
        return -1;
    }
    /*计算要拷贝文件字符个数*/
    int len = get_src_file_len(argv[1],argv[2]);
    printf("len = %d\n",len);
    //新建子进程
    pid_t pid;
    pid = fork();

    if(pid < 0){
       printf("fork error");
    }else if(pid == 0){
        printf("child start = %d,len=%d\n",0,len/2);
        //进程写前半部分
        copy_file(argv[1],argv[2],0,len/2);
        exit(EXIT_SUCCESS);//退出进程的时候会刷新缓冲区
    }else{
        printf("parent start = %d,len=%d\n",len/2,len-len/2);
        //进程写后半部分
        copy_file(argv[1],argv[2],len/2,(len-len/2));
        wait(NULL);//阻塞等待回收子进程的资源
    }
    return 0;
}
执行结果

在这里插入图片描述

2.2(非命令行指定)使用父子进程拷贝同一个文件，父进程拷贝前半部分，子进程拷贝后半部分

#include <stdio.h> // Shift  +  Alt  + F     实现代码的对齐；
/* fork函数的头文件*/
#include <sys/types.h>
#include <unistd.h>

/* open函数的头文件---文件IO*/
//#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
/*wait函数的头文件*/
#include <wait.h>

/* lseek函数的头文件---文件IO*/
//#include <sys/types.h>
//#include <unistd.h>

/*父子进程拷贝文件*/
int copy_2(int fd, int df)
{
    int ret, ret0, ret1;
    char buy[1];
    //读取目标要拷贝的文件的字节数
    ret1 = lseek(fd, 0, SEEK_END) / 2;
    //记录已经读取字节数
    int i = 0;
    /*进程写前/后半部分*/
    //进程写前半部分
    // SEEK_END从结尾开始 ;lseek功能：修改文件中光标的位置，
    //返回值：成功返回光标当前位置到开头的字节数
    if ((ret0 = lseek(df, 0, SEEK_END)) <= 0) //还没有进程执行
    {
        lseek(fd, 0, SEEK_SET);
        while ((ret = read(fd, buy, sizeof(buy))) > 0 && i < ret1)
        {
            write(df, buy, ret);
            i += ret;
        }
        printf("前半部分\n");
    }
    //进程写后半部分
    else if ((ret0 = lseek(df, 0, SEEK_END)) > 0) //进程已经执行
    {
        // SEEK_SET从头开始
        lseek(fd, ret0, SEEK_SET);
        while ((ret = read(fd, buy, sizeof(buy))) > 0)
        {
            write(df, buy, ret);
        }
        printf("后半部分\n");
    }
    return 0;
}

int main(int argc, char const *argv[])
{
    int fd, df;

    //先打开目标，要拷贝的文件
    if ((fd = open("./01.txt", O_RDONLY)) == -1)
        printf("open src error\n");
    //打开拷贝存放的文件                  //a+
    if ((df = open("./03-03作业-存放拷贝.txt", O_RDWR | O_APPEND | O_CREAT, 0664)) == -1)
        printf("open src error\n");

    pid_t pid;

    char s1[50] = {0};

    //创建子进程
    pid = fork(); // fork成功父进程收到子进程的PID，子进程收到0.

    if (pid < 0)
    {
        printf("fork error\n");
    }

    else if (pid == 0)
    {
        printf("\n");
        printf("这是子进程\n");
        printf("\n");
        copy_2(fd, df);
    }
    else
    {
        printf("这是父进程\n");
        printf("\n");
        copy_2(fd, df);
        wait(NULL); //阻塞等待回收子进程的资源
    }

    return 0;
}
执行结果

在这里插入图片描述

2.3 (命令行指定)使用三个进程拷贝同一个文件，每个进程拷贝文件的1/3

#include <stdio.h> // Shift  +  Alt  + F     实现代码的对齐；
/* fork函数的头文件*/
#include <sys/types.h>
#include <unistd.h>
/* open函数的头文件---文件IO*/
//#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
/*wait函数的头文件*/
#include <wait.h>

/*exit*/
#include <stdlib.h>

/* lseek函数的头文件---文件IO*/
//#include <sys/types.h>
//#include <unistd.h>


/*计算要拷贝文件字符个数*/
int get_src_file_len(const char *srcfile,const char * destfile)
{
    int sfd,dfd;
    int len=0;
    //打开目标要拷贝的文件
    if((sfd = open(srcfile,O_RDONLY))==-1){//只读
        printf("open srcfile error");
    }
    //打开存放拷贝的文件
    if((dfd = open(destfile,O_RDWR|O_CREAT|O_TRUNC,0664))==-1){
                            //读写| 创建文件| 清空文件
        printf("open destfile error");
    }
    //读取目标要拷贝的文件的字节数
    len = lseek(sfd,0,SEEK_END);

    close(sfd);//关闭文件
    close(dfd);
    return len;
}
/*父子进程拷贝文件*/
int copy_file(const char *srcfile,const char * destfile,int start,int len)
{
    int sfd,dfd;
    char buf[10] = {0};
    int ret=0;
    //记录已经读取字节数
    int i = 0;
    //打开目标要拷贝的文件
    if((sfd = open(srcfile,O_RDONLY))==-1){//只读
        printf("open srcfile error");
    }
    //打开存放拷贝的文件
    if((dfd = open(destfile,O_RDWR))==-1){//读写
        printf("open destfile error");
    }
    //光标从头开始，移动start
    lseek(sfd,start,SEEK_SET);
    lseek(dfd,start,SEEK_SET);

    while(1){
        ret = read(sfd,buf,sizeof(buf));

        i+=ret;//记录已经读取字节数
        //结尾||读多了
        if(ret==0 || i>len) {
           write(dfd,buf,ret-(i-len)); 
           break;
        }  
        write(dfd,buf,ret); 
    }
    close(sfd);
    close(dfd);
    return 0;
}

int main(int argc,const char * argv[])
{
    //检测命令行 3个参数
    if(argc != 3){
        fprintf(stderr,"input error,try again\n");
        fprintf(stderr,"usage:./a.out srcfile,destfile\n");
        return -1;
    }
    /*计算要拷贝文件字符个数*/
    int len= get_src_file_len(argv[1],argv[2]);
    printf("len = %d\n",len);
    //新建子进程
    pid_t pid,pid1;
    pid = fork();
    if(pid < 0){
        printf("fork error");
    }else if(pid == 0){
        printf("child1 start = %d,len=%d\n",0,len/3);
        //进程写前1/3部分
        copy_file(argv[1],argv[2],0,len/3);
        exit(EXIT_SUCCESS);
    }else{
        //新建子进程
        pid1=fork();
        if(pid1<0){
            printf("fork pid1 process error");
        }else if(pid1 == 0){
            printf("child2 start = %d,len=%d\n",len/3,(len/3)*2);
            //进程写中1/3部分
            copy_file(argv[1],argv[2],len/3,(len/3)*2);
            exit(EXIT_SUCCESS);
        }
        //进程写最后半部分
        printf("parent start = %d,len=%d\n",(len/3)*2,len-(len/3)*2);
        copy_file(argv[1],argv[2],(len/3)*2,len-(len/3)*2);
        wait(NULL); //阻塞回收子进程，但是回收那个子进程的资源不确定，只要回收一个就会退出
        wait(NULL); //阻塞回收子进程，但是回收那个子进程的资源不确定，只要回收一个就会退出
    }
    return 0;
}
执行结果

在这里插入图片描述

2.4 (非命令行指定)使用三个进程拷贝同一个文件，每个进程拷贝文件的1/3

#include <stdio.h> // Shift  +  Alt  + F     实现代码的对齐；
/* fork函数的头文件*/
#include <sys/types.h>
#include <unistd.h>

/* open函数的头文件---文件IO*/
//#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
/*wait函数的头文件*/
#include <wait.h>

/* lseek函数的头文件---文件IO*/
//#include <sys/types.h>
//#include <unistd.h>

/*3进程拷贝文件*/
int copy_3(int fd, int df)
{
    int ret, ret0, ret1;
    char buy[1];
    //读取目标要拷贝的文件的字节数
    ret1 = lseek(fd, 0, SEEK_END) / 3;
    //记录已经读取字节数
    int i = 0;
    /*进程写前/中/后部分*/
    //进程写前部分
    // SEEK_END从结尾开始 ;lseek功能：修改文件中光标的位置，
    //返回值：成功返回光标当前位置到开头的字节数
    if ((ret0 = lseek(df, 0, SEEK_END)) <= 0) //还没有进程执行
    {
        lseek(fd, 0, SEEK_SET);
        while ((ret = read(fd, buy, sizeof(buy))) > 0 && i < ret1)
        {
            write(df, buy, ret);
            i += ret;
        }
        printf("前部分\n");
    }
    //进程写中部分
    else if ((ret0 = lseek(df, 0, SEEK_END))==ret1) //进程已经执行
    {
        // SEEK_SET从头开始
        lseek(fd, ret0, SEEK_SET);
        while ((ret = read(fd, buy, sizeof(buy))) > 0 && i < ret1)
        {
            write(df, buy, ret);
            i += ret;
        }
        printf("中部分\n");
    }
    //进程写后部分
    else //进程已经执行
    {
        ret0 = lseek(df, 0, SEEK_END);
        // SEEK_SET从头开始
        lseek(fd, ret0, SEEK_SET);
        while ((ret = read(fd, buy, sizeof(buy))) > 0)
        {
            write(df, buy, ret);
        }
        printf("后部分\n");
    }
    return 0;
}

int main(int argc, char const *argv[])
{
    int fd, df;

    //先打开目标，要拷贝的文件
    if ((fd = open("./01.txt", O_RDONLY)) == -1)
        printf("open src error\n");
    //打开拷贝存放的文件                  //a+
    if ((df = open("./04-04作业-存放3进程拷贝.txt", O_RDWR | O_APPEND | O_CREAT, 0664)) == -1)
        printf("open src error\n");

    pid_t pid;

    char s1[50] = {0};

    //创建子进程
    pid = fork(); // fork成功父进程收到子进程的PID，子进程收到0.

    if (pid < 0)
    {
        printf("fork error\n");
    }

    else if (pid == 0)
    {
        printf("\n");
        printf("这是子1进程\n");
        printf("\n");
        copy_3(fd, df);
    }
    else
    {
        //父进程再创建子进程
        pid_t pid1;
        pid1 = fork();
        if (pid1 < 0)
        {
            printf("fork error\n");
        }

        else if (pid1 == 0)
        {
            printf("\n");
            printf("这是子2进程\n");
            printf("\n");
            copy_3(fd, df);
        }
        else
        {
            printf("这是父进程\n");
            printf("\n");
            copy_3(fd, df);
            wait(NULL); //阻塞等待回收子进程的资源
            wait(NULL); //阻塞等待回收子进程的资源
        }
    }
        return 0;
    }
执行结果

在这里插入图片描述

6. 非原创

菜鸟看点
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多进程拷贝文件
一点星光
08-04 565
拷贝文件进程 #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <stdlib.h> #include <string.h> //错误码 enum ecode_err{ argument_list_err, src_open_err, des_o
使用父子两个进程拷贝同一个文件，父进程拷贝前一半，子进程拷贝后一半。
qq_25230759的博客
11-11 401
使用父子俩个进程拷贝同一个文件，父进程拷贝前一半，子进程拷贝后一半。
c语言，多线程实现多个文件同步复制功能
weixin_43819521的博客
09-03 963
使用多线程实现多个文件同步复制功能，并在控制台显示复制的进度，进度以百分比实现； 例如：将/home/XXX 复制 /home//dir,提示：XXX文件已复制20%，XXX文件已复制50%，.....,XXX文件已复制100%,xxx文件复制完成!设计程序，
Linux IO 实现打印文件夹下所有非隐藏文件信息，及父子进程实现文件拷贝（子进程先拷贝后半部分，父进程后拷贝前半部分）
YamamotoIsoroku的博客
02-01 242
Linux IO 实现打印文件夹下所有非隐藏文件信息，及父子进程实现文件拷贝（子进程先拷贝后半部分，父进程后拷贝前半部分）
Linux 多进程拷贝
辰星的博客
05-31 407
仅供本人参考，没有原理介绍，谨慎阅读 利用Linux系统提供的一系列函数实现多进程拷贝命令。实现的时候由于对进程控制太过生硬，一直出现莫名其妙的问题。最后参考了其他人是如何在fork后控制子进程的流程的，终于完成了。 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <sys/mman.h> #include <sy.
用C语言编写multipart/form-data实现上传文件
02-26
本话题聚焦于使用C语言实现一个不依赖于curl等外部库的multipart/form-data文件上传功能。multipart/form-data是一种HTTP协议中用于处理多部分数据的格式，通常用于上传文件。 在C语言中实现这个功能需要理解HTTP...
C语言模拟实现Linux文件系统
09-12
C语言模拟实现Linux文件系统 1、在内存中开辟一块空间来模拟文件系统的运行，不读写硬盘。 2、面向单用户、单任务，不考虑并发，不考虑文件属主、组等概念。 3、程序开始后，初始化并接收用户输入。若输入”enter”...
C语言-文件IO知识点
最新发布
05-23
在深入探讨 C 语言的文件输入输出（File Input/Output，简称文件 IO）知识点之前，让我们先理解一下为什么文件操作对于嵌入式程序员如此重要。在 Linux 系统中，遵循“万物皆文件”的原则，无论是硬件设备、网络接口...
C语言实现文本文件/二进制文件格式互换
08-26
C语言实现文本文件/二进制文件格式互换 本文主要介绍了使用C语言实现文本文件和二进制文件格式互换，提供了详细的代码实现和步骤解释，具有重要的参考价值。 Knowledge Point 1: 文本文件和二进制文件的区别 在...
c语言多线程拷贝,linuc下实现多线程拷贝文件（C语言版本）
weixin_42345036的博客
05-22 686
网上已经有很多代码，本来打算理解一下别人的代码，拷贝过来执行就可以了，但是找了两个博客的代码，执行都报错了，于是就研究了一下mmap实现多线程拷贝，参考https://blog.csdn.net/woshichaoren1/article/details/85227528https://www.cnblogs.com/lianshuiwuyi/p/7506972.html实现了，代码有些不精简，可...
用两个进程拷贝文件，子进程拷贝前一半，父进程拷贝后一半
lpr2438275530的博客
08-03 166
linux IO进程 多进程创建
C语言实现一个目录的拷贝
Catherln的博客
08-16 2841
拷贝目录
多进程和多线程文件拷贝
tizileo的专栏
05-10 1273
1. 线程与进程的异同点 A.相同点 1):  比如都有自己在系统中唯一标识ID,一组寄存器(pc指针)，状态（6种），调度优先级以及所要遵循的调度策略。 2):  每个进程都有一个进程控制块，线程也拥有一个线程控制块(在Linux内核，线程控制块与进程控制块用同一个结         构体描述,即struct  task_struct)，这个控制块包含线
C语言的多进程(3)
风吹过
01-31 3345
欢迎加入QQ：498903810 一起交流、讨论知识，里面有大佬，也有小白，天下码农一家亲，大家一起讨论进步。 优化ls -l的获取权限方式点击查看 #include #include #include #include #include #include #include #include #include #include int main() {
使用两个进程拷贝同一个文件（各拷贝一半）
augeksjsj的博客
08-03 220
两个进程同时拷贝一个文件，把拷贝结果放在两个不同文件。源文件text.txt。
用父子进程拷贝一张图片，其中子进程先拷贝后半部分，父进程后拷贝前半部分。要求用文件IO实现。
qq_72815752的博客
09-03 158
IO进程
多线程复制文件c语言,Linux下C语言实现多线程文件复制
weixin_29858081的博客
05-22 400
1、具体思路把一个文件分成N份，分别用N个线程copy，每个线程只读取指定长度字节大小的内容最后一个线程的源文件所指定的结束位置是文件的实际大小每个线程读取指定源文件部分的起始位置和结束位置的内容到缓冲区每个线程将缓存中的内容写入目的文件的指定开始位置和结束位置主线程必须等到所有线程copy完成后才能退出2.有关文件操作的函数2.1. 文件的打开和关闭2.1.1 open()函数open()函数的...
linux父子进程同步实验,Linux-父子进程的简单同步
weixin_28785069的博客
05-13 1268
int fork()功能：创建一个子进程返回值：0-创建成功，-1-创建进程失败，>0-创建进程成功，返回返回子进程idint wait(int * status)功能：将调用的进程挂起，等待子进程运行结束参数：指向整数的指针，0-子进程正常结束，非0-出现运行有误返回值：调用正常-子进程id，调用进程无子进程-调用失败，返回-1int exit()功能：终止进程的执行返回值：无sleep(...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值