C language implements file copy function (including text files and binary files)

Copying of files is a common function, which requires writing a piece of code, allowing the user to input the file to be copied and the newly created file, and then copying the file. The files that can be copied include text files and binary files. You can copy 1G movies or 1Byte txt documents.

The main idea of ​​realizing file copying is to open up a buffer, continuously read the content from the original file to the buffer, and write the content in the buffer to the newly created file after each reading, until the content of the original file is read. Finished reading.

There are two key issues to be solved here:
1) How big is the appropriate buffer to open up? If the buffer is too small, the number of reads and writes will increase, and if the buffer is too large, the efficiency cannot be significantly improved. At present, the sectors of most disks are 4K aligned. If the read and write data is not an integer multiple of 4K, it will be read across sectors, reducing efficiency, so we open up a 4K buffer.

2) The data in the buffer has no end mark. If the buffer is not full, how to determine the number of bytes written? The best way is to return the number of bytes read for each read.

The prototype of fread() is:

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

It returns the number of blocks successfully read and written, which is less than or equal to count. If we make the parameter size equal to 1, then what is returned is the number of bytes read.

Note: fopen() must open the file in binary form, not in text form, otherwise the system will perform some processing on the file, if it is a text file, such as .txt, etc., there may be no problem, but if it is a file in other formats , like .mp4, .rmvb, .jpg, etc., will make an error after copying and cannot be read.

Code:

1. #include <stdio.h>
2. #include <stdlib.h>
4. int copyFile(char *fileRead, char *fileWrite);
6. int  main () {
7. char fileRead [ 100 ];  // filename to copy
8. char fileWrite [ 100 ];  // copied file name
10. // get user input
11. printf ( "File to copy:" );
12. scanf("%s", fileRead);
13. printf ( "Copy file to: " );
14. scanf("%s", fileWrite);
16. // do the copy operation
17. if( copyFile(fileRead, fileWrite) ){
18. printf ( "Congratulations, the file was copied successfully! \n " );
19. }else{
20. printf ( "File copy failed! \n " );
21. }
23. return 0;
24. }
26. /**
27. * file copy function
28. *  @param  fileRead the file to copy
29. *  @param  fileWrite save path of the copied file
30. *  @return  int 1: Copy succeeded; 2: Copy failed
31. **/
32. int copyFile(char *fileRead, char *fileWrite){
33. FILE *fpRead ;  // point to the file to copy 
34. FILE *fpWrite ;  // point to the copied file 
35. int bufferLen  =  1024 * 4 ;  // buffer length
36. char  *buffer  =  ( char *) malloc (bufferLen );  // open up the buffer
37. int readCount ;  // number of bytes actually read
39. if( (fpRead=fopen(fileRead, "rb")) == NULL || (fpWrite=fopen(fileWrite, "wb")) == NULL ){
40. printf("Cannot open file, press any key to exit!\n");
41. getch();
42. exit(1);
43. }
45. // Continuously read the content from fileRead, put it in the buffer, and then write the content of the buffer to fileWrite
46. while( (readCount=fread(buffer, 1, bufferLen, fpRead)) > 0 ){
47. fwrite(buffer, readCount, 1, fpWrite);
48. }
50. free(buffer);
51. fclose(fpRead);
52. fclose(fpWrite);
54. return 1;
55. }

operation result:

File to copy: d://1.mp4
Copy the file to: d://2.mp4
Congratulations, the file was copied successfully!

If the file does not exist, a prompt is given and the program is terminated:

File to copy: d://123.mp4
Copy the file to: d://333.mp4
d://cyuyan.txt: No such file or directory

Line 46 is the core code for file copying. Through the fread() function, each time bufferLen bytes are read from the fileRead file, put into the buffer, and then the content of the buffer is written into the fileWrite file through the fwrite() function.

Under normal circumstances, bufferLen bytes are read each time, that is, readCount=bufferLen; if the file size is less than bufferLen bytes, or the end of the file is read, the actual bytes read will be less than bufferLen, that is, readCount< bufferLen. So when writing files through fwrite(), readCount should prevail.