linux环境下支持通配符的文件拷贝功能

blacktt

三楼说的很清楚了，就是你在命令行输入命令时，linux中的shell已经为你展开了文件名通配，这是由shell完成的，你的程序不用管的，一定要自己处理，就用glob吧

zneilnet

回复 11# blacktt


    哦，那如果在命令行中输入：<程序名> /home/sd/Desktop/ab/*.zip /home/sd/Desktop/cd 的话，argc的值为什么不是3呢？？

flw

回复  flw


    什么都不用做啊？？我不是很懂，麻烦大哥讲讲吧。
zneilnet 发表于 2011-03-16 10:32

你先不要考虑通配符的情况，做一个程序，比如实现：

mycp file1 file2 file3 foo/

然后你再试着用通配符调用一下，然后你就会神奇的发现，你居然已经实现了一个支持通配符功能的文件拷贝程序！

zneilnet

回复 13# flw


    哦，我现在的程序接受的两个参数，argv[1] 是源文件的路径，argv[2]是目标文件的路径，那为什么在命令行中输入<程序名> /home/ad/* /home/ad/fg 之后，argc会不是3呢？

madoldman

回复 14# zneilnet


    前面几位跟你说的很清楚了吧，shell会把通配符展开，然后传到你的程序里

zneilnet

回复 15# madoldman


    哦，谢谢哈，我比较笨，

JohnBull

man 3 glob

zneilnet

回复 17# JohnBull


    哦，谢谢咯

zneilnet

在各位的帮助下，小弟完成了相应的功能，代码如下：

1. #include <stdio.h>
   
2. #include <dirent.h>
   
3. #include <errno.h>
   
4. #include <sys/stat.h>
   
5. #include <string.h>
   
6. #include <fcntl.h>
   
7. #include <cstdlib>
   
8. #include <unistd.h>
   
9. #include <fnmatch.h>
   
10. #define BUFFER_SIZE 1048576
    
11. 
    
12. void copy_file(char *src_path, char *dst_path)
    
13. {
    
14.         int from_fd;
    
15.         int to_fd;
    
16.         int bytes_read;
    
17.         int bytes_write;
    
18.         char buffer[BUFFER_SIZE];
    
19.         char *p;
    
20. 
    
21.         if((from_fd = open(src_path, O_RDONLY)) == -1) {
    
22.                 fprintf(stderr, "Open %s Error:%s\n", src_path, strerror(errno));
    
23.                 exit(1);
    
24.         }
    
25. 
    
26.         if((to_fd = open(dst_path, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR)) == -1) {
    
27.                 fprintf(stderr,"Open %s Error:%s\n", dst_path, strerror(errno));
    
28.                 exit(1);
    
29.         }
    
30. 
    
31.         while((bytes_read = read(from_fd, buffer, BUFFER_SIZE))) {
    
32.                 if((bytes_read == -1) && (errno != EINTR)) {
    
33.                         fprintf(stderr,"read  %s Error:%s\n", src_path, strerror(errno));
    
34.                         break;
    
35.                 }
    
36.                 else if(bytes_read > 0) {
    
37.                         p = buffer;
    
38.                         while((bytes_write = write(to_fd, p, bytes_read))) {
    
39.                                 if((bytes_write == -1) && (errno != EINTR)) {
    
40.                                         fprintf(stderr,"write %s Error:%s\n", dst_path, strerror(errno));
    
41.                                         break;
    
42.                                 }
    
43.                                 else if(bytes_write == bytes_read)
    
44.                                         break;
    
45.                                 else if(bytes_write > 0) {
    
46.                                         p += bytes_write;
    
47.                                         bytes_read -= bytes_write;
    
48.                                 }
    
49.                         }
    
50.                         if(bytes_write == -1) {
    
51.                                 fprintf(stderr,"write %s Error:%s\n", dst_path, strerror(errno));
    
52.                                 break;
    
53.                         }
    
54.                 }
    
55.         }
    
56.         close(from_fd);
    
57.         close(to_fd);
    
58. }
    
59. 
    
60. 
    
61. void copy_dir(char *name,char *p,char *dst)
    
62. {
    
63.         DIR *dp;
    
64.         DIR *dp1;
    
65.         char pp[255];
    
66.         char pn[255];
    
67.         struct stat sbuf;
    
68.         struct dirent *dir;
    
69. 
    
70.         if((dp = opendir(name)) == NULL) {
    
71.                 printf("Open Directory %s Error:%s\n", name, strerror(errno));
    
72.                 exit(1);
    
73.                 }
    
74.         while ((dir = readdir(dp)) != NULL) {
    
75.                 if (dir->d_ino==0)
    
76.                         continue;
    
77.                 strcpy(pn,name);
    
78.                 strcat(pn,"/");
    
79.                 strcat(pn,dir->d_name);
    
80.                 strcpy(pp,dst);
    
81.                 strcat(pp,"/");
    
82.                 strcat(pp,dir->d_name);
    
83.                 if (lstat(pn,&sbuf) < 0) {
    
84.                         perror(pn);
    
85.                         closedir(dp);
    
86.                         exit(1);
    
87.                 }
    
88. 
    
89.                 if ( ((sbuf.st_mode & S_IFMT) != S_IFLNK) &&
    
90.                      ((sbuf.st_mode & S_IFMT) == S_IFDIR) &&
    
91.                      (strcmp(dir->d_name, ".") != 0) &&
    
92.                      (strcmp(dir->d_name, "..") != 0) ) {
    
93.                         if((dp1 = opendir(pn)) == NULL) {
    
94.                                 printf("Open Directory %s Error:%s\n",pn,strerror(errno));
    
95.                                 exit(1);
    
96.                         }
    
97.                         if((mkdir(pp, 0700)))
    
98.                                 break;
    
99.                         copy_dir(pn,p,pp);
    
100.                 }
     
101. 
     
102.                 else if ( ((sbuf.st_mode & S_IFMT) != S_IFLNK) &&
     
103.                           ((sbuf.st_mode & S_IFMT) == S_IFREG) &&
     
104.                           (strcmp(dir->d_name,".") != 0) &&
     
105.                           (strcmp(dir->d_name, "..") != 0) ) {
     
106.                                         if(fnmatch(p,dir->d_name,FNM_PATHNAME|FNM_PERIOD)== 0)
     
107.                            copy_file(pn,pp);
     
108.                                         else if(fnmatch(p,dir->d_name,FNM_PATHNAME|FNM_PERIOD)== FNM_NOMATCH)
     
109.                                           continue;
     
110.                 }
     
111.         }
     
112. }
     
113. 
     
114. 
     
115. int main(int argc,char **argv)
     
116. {
     
117. 
     
118.         char *program_name;
     
119.         DIR *dp,*dq;
     
120. //       struct dirent *dir;
     
121. 
     
122. 
     
123. 
     
124.         program_name = argv[0];
     
125.         if(argc != 4) {
     
126.                 printf("%d",argc);
     
127.                 fprintf(stderr,"Usage:%s fromdir todir\n", argv[0]);
     
128.                 exit(1);
     
129.         }
     
130.         if((dp = opendir(argv[1])) == NULL) {
     
131.                 printf("Open Directory %s Error:%s\n", argv[1], strerror(errno));
     
132.                 exit(1);
     
133.         }
     
134.                 if((dq = opendir(argv[3])) == NULL)
     
135.                 {
     
136.                         if((mkdir(argv[3],0777)))
     
137.                         {
     
138.                                 printf("make dir %s is failed \n",argv[3]);
     
139.                                 exit(1);
     
140.                         }
     
141.                 }
     
142. 
     
143.         copy_dir(argv[1], argv[2],argv[3]);
     
144. 
     
145.         closedir(dp);
     
146.                 closedir(dq);
     
147.         exit(0);
     
148. }
     

复制代码

编译：gcc -Wall copy_file.cc -o copy
执行：./copy /home/zneil/Desktop "*.zip" /home/zneil/Desktop/abc