IO拷贝文件大全

最新推荐文章于 2024-06-28 01:24:53 发布
最新推荐文章于 2024-06-28 01:24:53 发布
阅读量321 收藏
点赞数
分类专栏： 嵌入式 文章标签： c语言 linux IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41555003/article/details/126817413
版权

文章目录

1. 文件拷贝简介

在shell命令中有cp命令，能实现文件拷贝

cp srcfile destfile

若文件destfile不存在，则将srcfile复制一份取名为destfile；
若文件destfile存在，则将srcfile复制一份取名为destfile，覆盖原来的destfile；
文件存在则清空，文件不存在则创建。

2. 使用fgetc/fputc拷贝文件

  1. 使用open以只读的方式打开srcfile，然后以只写的方式打开destfile。
FILE *fp = open("srcfilr","r"); //以只读的方式打开文件，光标定位在文件开头 
//若打开文件成功则返回文件的文件指针，若打开失败则返回NULL，并置为错误码。
if(fp == NULL){
    printf("errno = %d\n", errno);//errno就是错误码，系统定义的可直接使用
    printf("%s\n", strerror(errno));//错误码就是个数字，如果不知道其含义可以使用strerror(errno)打印错误码对应的信息
    perror("fopen file");//可以使用perror直接打印出错误信息，"fopen file"字符串是附加信息，若不加换行，则错误信息会在字符串后接 ':'加错误信息；加换行后 ':'和错误信息会在下一行显示。
    return -1;//返回-1
}
FILE *fq = open("destfile", "w");//以只读的方式打开文件destfile，若文件存在则清空文件，若文件不存在则创建文件。
if(fp == NULL){
    //可使用perror打印文件错误信息，然后返回-1
    perror("fopen file");
    return -1;
}
  1. 循环从srcfile文件中读取文件，然后写入到destfile中，直至读到文件结束符EOF。
char ch;
while((ch = fgetc(fp))!=EOF){
    fputc(ch, fq);
}
  1. 整体代码
//可将头文件封装到一个.h文件中，然后再将一些宏也封装到此文件中，最后将此文件放入/usr/include/文件夹中，这样就可以使用<>了，也不用在编译的时候加头文件路径了
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, const char *argv[])
{
    FILE *fp, *fq;
    char ch;
    //文件名通过命令行传参
    if((fp = fopen(argv[1], "r"))==NULL){
        printf("%s",argv[1]);
        //下面两句经常使用，也可封装到头文件中
        perror("");
        return -1;
    }
    if((fq = fopen(argv[2],"w"))==NULL){
        printf("%s",argv[2]);
        perror("");
        return -1;
    }
    while((ch = fgetc(fp))!=EOF){
        fputc(ch, fq);
    }
    //关闭文件
    fclose(fp);
    fclose(fq);
    return 0;
}

3. 使用fgets/fputs拷贝文件

步骤和fgetc/fputc相同

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

void cp_file(FILE* fp, FILE* fq)
{
    char buf[10];
    //fgets在读到换行符是会结束，并将换行符保存在buf中，fgets最多能读取size - 1，size是fgets的第二个参数。
    //fgets在读到最后一行时，会先把EOF之前的读完，然后第二次再读取EOF，这时会返回NULL
    while (fgets(buf, sizeof(buf), fp)) {
        //这地点应该加一个判断，判断是否成功写入文件，一般都会写成功，所以在这里默认写入成功
        fputs(buf, fq);
    }
}

int main(int argc, const char* argv[])
{
    FILE *fp, *fq;

    if ((fp = fopen(argv[1], "r")) == NULL) {
        perror("open file error");
        return -1;
    }
    if ((fq = fopen(argv[2], "w")) == NULL) {
        perror("open file error");
        return -1;
    }
    cp_file(fp, fq);
    fclose(fp);
    fclose(fq);
    return 0;
}

4. 使用fread/fwrite拷贝文件

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

void copy_file(FILE* sfp, FILE* dfp)
{
    char buf[128] = { 0 };
    int ret;
    //当读取到文件结尾的时候feof(sfp)返回真
    //如果读取的时候失败了ferror(sfp)也是真
    //只有两者同时为假的时候才能循环读写数据
    while (!(feof(sfp) || ferror(sfp))) {
        ret = fread(buf, 1, sizeof(buf), sfp);
        fwrite(buf, 1, ret, dfp);
    }
}

int main(int argc, const char* argv[])
{
    FILE *fp, *fq;
    if ((fp = fopen(argv[1], "r")) == NULL) {
        printf("%s", argv[1]);
        perror("");
        return -1;
    }
    if ((fq = fopen(argv[2], "w")) == NULL) {
        printf("%s", argv[2]);
        perror("");
        return -1;
    }
    copy_file(fp, fq);
    fclose(fp);
    fclose(fq);
    return 0;
}

5. 封装头文件

将所需要的头文件封装到一个.h文件中，将复用行较高的语句定义成宏，并将此文件移动到/usr/include/路径下。
若以后需要可以直接向此头文件中添加内容，在使用的时候我们只需引入这一个头文件即可。

#ifndef __HEAD_H__
#define __HEAD_H__

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

#define PRINT_ERR(msg) \
    do {               \
        perror(msg);   \
        return -1;     \
    } while (0)

#endif

6. 使用read/write拷贝文件

#include <head.h>

int main(int argc, const char* argv[])
{
    int fd1, fd2, ret;
    char buf[128] = { 0 };
    //以只读的方式打开文件，若成功则返回文件描述符，失败返回-1
    if ((fd1 = open(argv[1], O_RDONLY)) == -1)
        //头文件中定义的宏
        PRINT_ERR("open file1 error");
    //以只读的方式打开文件，若文件存在则清空文件，不存在则创建文件，文件权限为(0666 &(~umask))
    if ((fd2 = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1)
        PRINT_ERR("open file2 error");
    //read成功返回读取到的字节的个数，0表示读取到了文件的结尾，失败返回-1置位错误码，所以只要read的返回值大于0都写文件
    while ((ret = read(fd1, buf, sizeof(buf))) > 0) {
        //将buf中的内容写入文件，写入长度为ret
        write(fd2, buf, ret);
    }

    return 0;
}

7. 多进程拷贝文件

父进程拷贝文件的前半部分，子进程拷贝文件的后半部分

  1. 首先求出想要拷贝文件的长度
//将光标定位到文件的结尾，lseek返回是光标距离文件开头的字节数，也就是文件的大小
int len = lseek(fd, 0, SEEK_END);
  1. 查看目标文件是否有，若有则清空，若没有则创建
if((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1){
        PRINT_ERR("open destfile error");
}
  1. 创建子进程
pid_t pid = fork();
//创建子进程，成功父进程返回子进程的pid，子进程返回0；失败返回-1
  1. 文件拷贝
    和其他文件拷贝没有什么区别，就是要注意光标的位置，一定要在子进程和父进程中分别打开文件，否则在创建子进程的时候子进程会拷贝父进程中的所有资源，包括文件的光标位置，也也就是父进程和子进程公用一个光标，任意进程修改光标都会对另一进程造成影戏。
  2. 全部代码
#include <head.h>

//检查目标文件是否创建
int InitFile(const char *filename){
    int fd;
    if((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1){
        PRINT_ERR("open destfile error");
    }
    close(fd);
    return 0;
}
//求文件的长度
int filelen(const char *filename){
    int fd;
    if((fd = open(filename, O_RDONLY)) == -1)
        PRINT_ERR("open srcfile error");
    int len = lseek(fd, 0, SEEK_END);
    return len;
}
//拷贝文件
int copy_file(const char *srcfile, const char *destfile, int n, int len){
    int sfd, dfd;
    char buf[128];
    int count = 0;
    //只能在父进程和子进程中分别打开文件
    //以只读方式打开源文件
    if((sfd = open(srcfile,O_RDONLY)) == -1)
        PRINT_ERR("open srcfile error");
    //以读写的方式开打文件，以只写的方式也可以
    if((dfd = open(destfile, O_RDWR)) == -1)
        PRINT_ERR("open destfile error");
    //分别定位文件的光标位置，若是子进程先执行，此时文件长度为0，lseek是可以将光标定位到距文件开头n个字节位置
    lseek(sfd, n, SEEK_SET);
    lseek(dfd, n, SEEK_SET);
    //使用read/write读写文件
    while(count = read(sfd, buf, sizeof(buf))){
        //len的作用主要是防止父进程在拷贝文件的时候将子进程拷贝的前几个字符覆盖
        //每次都将还需读取的长度减去一睹字节
        len -= count;
        //当最后一次读取长度大于所需长度，那么我们在写的时候只需要写入我们需要的长度
        if(len < 0)
            count += len;
        write(dfd, buf, count);
    }
    return 0;
}
int main(int argc, const char* argv[])
{
    int fd, wfd;

    int len = filelen(argv[1]);
    if(len == -1){
        fprintf(stderr, "srcfilelen  == -1");
        return -1;
    }

    InitFile(argv[2]);
    pid_t pid = fork();

    if (pid == -1) {
        PRINT_ERR("fork error");
    } else if (pid == 0) {
        copy_file(argv[1], argv[2], len / 2, len - len / 2);
    } else {
       copy_file(argv[1],argv[2], 0, len / 2);
    }
    return 0;
}

8. 多线程拷贝文件

多线程拷贝文件的速度要比多进程拷贝文件的速度快

#include <head.h>

pthread_t tid1, tid2;
int file_len;

void CopyFile(int n, int len){
    int sfd, dfd;
    char buf[128];
    int count = 0;
    if ((sfd = open("hello.txt", O_RDONLY)) == -1) {
        printf("open srcfile error");
    }

    if ((dfd = open("world.txt", O_RDWR)) == -1) {
        printf("open destfile error");
    }

    lseek(sfd, n, SEEK_SET);
    lseek(dfd, n, SEEK_SET);

    while (count = read(sfd, buf, sizeof(buf))) {
        len -= count;

        if (len < 0)
            count += len;
        write(dfd, buf, count);
    }
}
//查看目标文件是否有
int InitFile(const char* filename)
{
    int fd;
    if ((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1) {
        PRINT_ERR("open destfile error");
    }
    close(fd);
    return 0;
}
//求源文件长度
int filelen(const char* filename)
{
    int fd;
    if ((fd = open(filename, O_RDONLY)) == -1)
        PRINT_ERR("open srcfile error");
    int len = lseek(fd, 0, SEEK_END);
    return len;
}
//根据不同的arg调用不同的处理函数
void* Func(void* arg)
{
    int n = 0, len = 0;
    int* flag = (int*)arg;

    if (*flag == 0) {
        n = 0;
        len = file_len / 2;
    } else {
        n = file_len / 2;
        len = file_len - n;
    }
    //printf("*flag = %d, n = %d, len = %d\n", *flag, n, len);
    CopyFile(n, len);
}

int main(int argc, const char* argv[])
{
    //为了方便，将文件写成固定的了，当让也可采用命令行传参
    file_len = filelen("hello.txt");
    if (file_len == -1) {
        fprintf(stderr, "srcfilelen  == -1");
        return -1;
    }

    InitFile("world.txt");

    //通过不同的标记拷贝文件不同的位置
    int flag = 0;
    if (errno = pthread_create(&tid1, NULL, Func, (void*)&flag))
        PRINT_ERR("create thread1 error");
    int flag1 = 1;
    if (errno = pthread_create(&tid2, NULL, Func, (void*)&flag1))
        PRINT_ERR("create thread2 error");
    //一定要阻塞等待线程结束，或者使用死循环，一定不要让进程结束，当进程结束时，所有的线程都会被销毁
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}
xiyu_dang
关注
专栏目录
io文件基本操作和拷贝文件
双链表
12-01 601
文件分为普通文件,目录文件和特殊文件. 1.普通文件即有后缀的一般文件,例如xxx.java xxx.txt. 2.目录文件即文件夹 3.特殊文件即和硬件相关的文件 普通文件在创建时应注意父级文件都应该存在,否则会抛出异常. 目录文件创建用mkdirs方法,不管多少级目录都可以创建 特殊文件… 普通文件: package threaddemo.iotest; import java.io.File; import java.io.IOException; public class IoTest {
JAVA中IO流的拷贝字节文件的3种方法
weixin_67240798的博客
03-03 1228
总所周知,JAVA在IO流 package Package6.problem; import java.io.*; public class copy { public static void main(String[] args) throws Exception{ //test1(); test2(); //test3(); } //第一种方法c public static void test1() throws E.
标准IO实现文件的复制
12-08
通过C语言用标准IO实现文件打复制;通过C语言用标准IO实现文件打复制;通过C语言用标准IO实现文件打复制;通过C语言用标准IO实现文件打复制;通过C语言用标准IO实现文件打复制;通过C语言用标准IO实现文件打复制;
IO_文件拷贝
weixin_43003240的博客
02-18 413
import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.Out...
IO流篇 -- 基于io流实现文件夹拷贝（拷贝子文件夹及子文件夹内文件）满满的干货
最新发布
2401_85763924的博客
06-28 678
小编这些年深知大多数初中级工程师，想要提升自己，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此我收集整理了一份《2024年Java全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！如果你需要这些资料，⬅专栏获取[外链图片转存中…(img-vhtSOR3s-1719509081984)]
IO文件拷贝
MADE_哒哒
02-22 478
利用java的IO流实现文件的拷贝。思路： 以程序为中转站的作用，对接输入流和输出流。便实现了文件的拷贝。也就是对上一篇博客两种流的结合。 https://blog.csdn.net/qq_40301026/article/details/87869205                                              源文件存放在study02下，命名为：ta....
IO实现文件拷贝
qq_51592187的博客
12-16 132
java中IO文件拷贝的基本方法 package IO; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class IOCop
io文件拷贝
sa1kou的博客
09-25 249
使用io和nio进行文件拷贝 1、io @Test public void iotest() throws Exception { InputStream in = new FileInputStream("C:\\shit.txt"); OutputStream out = new FileOutputStream("C:\\shit2.txt
demo.rar线程池、文件io拷贝
05-07
该项目使用了线程池进行多线程文件快速的拷贝，可同时复制不同的文件，在不同情况下和不同文件类型的文件以及多重嵌套的文件，该程序都能完美的进行拷贝。用户在使用时，需要输入两个参数，第一个是必须存在的复制...
java 利用io进行文件拷贝
12-14
利用io流编写的简单的文件拷贝小程序，可在控制台进行文件的拷贝.
C#拷贝文件简单实现方法
09-03
在C#编程语言中，拷贝文件是一个常见的操作，用于数据备份、文件传输等场景。本文主要介绍使用C#中的FileInfo类的CopyTo方法实现文件拷贝的简单方法。 FileInfo类是.NET框架中用于获取文件信息的类，它位于System....
IO拷贝文件两种方式
djv13876的博客
09-09 190
package CoreJavaPractice; import java.io.*; public class Practice_2 { public static void main(String[] args) throws IOException { copy_2(); ...
关于Io流里面文件拷贝
m0_67991381的博客
08-30 304
package com.file.copy; import java.io.*; public class FileCopy { /** * 将一个源文件拷贝到一个目标目录中 * @param src * @param targetDir */ public static void copyFile(File src, File targetDir) throws IOException { InputStream is =nul.
IO技术实现文件的拷贝
weixin_47267628的博客
04-10 868
IO技术实现文件的拷贝 步骤： 1：创建一个FileInputStream对象用于读取指定文件， 同时可以使用BufferedInputStream对象对FileInputStream进行包装 2：同时创建ByteArrayOutputStream ，用于保存读取到的数据 3：创建BufferedOutputStream 对象，用于一次将全部数据写入到指定目录中 4：关闭流 package com.haikang.io_; import java.io.*; /** * @author: 海康 *
利用IO流实现文件拷贝
m0_71542164的博客
06-11 265
利用IO流实现将一个文件拷贝到另一个文件中
IO流拷贝文件
m0_64027170的博客
04-02 282
1. import java.io.*; public class CopyFileDemo { public static void main(String[] args) { File file=new File("a.txt"); File file1=new File("b.txt"); // 创建目标数据源 // File file1=new File(file.getName()); InputStrea
简单文件Copy（Java IO 1-1）
yuiezt的专栏
08-14 330
简单的文件拷贝
用文件IO实现文件的拷贝
m0_47925131的博客
08-10 1299
用文件IO实现文件的拷贝
实现文件io拷贝
fgfxgfx的博客
03-11 170
思路就是定义一个字符串数组，然后从原文件不停的读，再不停的写到新的文件。当读完的时候返回值为0，跳出循环。 需要注意的地方是读的时候要读的个数比总长度少一个 ret = read(fd_from,buf,sizeof(buf) - 1); 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <unist...
Java IO库：文件与目录操作实战指南
本文档详细介绍了如何利用Java的IO类库进行一系列文件操作，包括创建目录、新建文件、删除文件以及文件拷贝。以下是具体步骤： 1. 新建目录：Java通过`java.io.File`类实现了文件和目录的管理。首先，我们需要定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值