要写一个file_copy函数

Herowinter

回复 20# cobras


哦，太感谢了，boost已经被老板否了，说那个库太大。
剩下的办法好像只有正则或自己解析，正则是C++11的，
老板应该也不会同意，只能自己处理了，正好可以参考一下
您的代码。

myworkstation

回复 17# Herowinter


    boost filesystem 不支持wildcards，wildcards实际上是shell进行解析的（Filename Expansion)，自己处理wildcards的话可以看看这几个函数（属于POSIX标准的一部分）：glob, glob_b, globfree,fnmatch,wordexp

Herowinter

回复 22# myworkstation


哦，非常感谢大神帮助，看看能不能说服老板用正则，这样好像代码简单点，
带通配符文件名中的  
    .=>\.
    *=>.*
    ? =>.
这样转换的正则应该和本来的通配符等价的。然后再写个函数递归遍历目录下
的所有文件目录,Windows有个FindFirstFile, POSIX有个opendir。再判断
一下文件名是不是match正则应该就可以了。

我现在的方案这样的，老板不认同，只能去啃您说的那几个函数了。

windoze

回复 22# myworkstation

Windows里wildcard解析是文件系统驱动做的（不知道是哪个脑残设计的…………）

cobras

发个windows文件通配例子。

1. #include <ctype.h>
   
2. #include <stdio.h>
   
3. #include <windows.h>
   
4. 
   
5. #define PATH_SPLITTER '\\'
   
6. 
   
7. #define LENGTH(a) (sizeof(a)/sizeof((a)[0]))
   
8. 
   
9. struct file_node
   
10. {
    
11.         long size;
    
12. };
    
13. 
    
14. int nstr_chr(const char *s, int off, int lmt, int c)
    
15. {
    
16.         for (; off < lmt; ++off) {
    
17.                 if (s[off] == c) {
    
18.                         return off;
    
19.                 }
    
20.         }
    
21.         return -1;
    
22. }
    
23. 
    
24. int nstr_rchr(const char *s, int off, int lmt, int c)
    
25. {
    
26.         for (; off < lmt; --lmt) {
    
27.                 if (s[lmt - 1] == c) {
    
28.                         return lmt;
    
29.                 }
    
30.         }
    
31.         return -1;
    
32. }
    
33. 
    
34. int nstr_npbrk(const char *s, int off, int lmt, const char *charset, int charset_len)
    
35. {
    
36.         for (; off < lmt; ++off) {
    
37.                 if (nstr_chr(charset, 0, charset_len, s[off]) != -1) {
    
38.                         return off;
    
39.                 }
    
40.         }
    
41.         return -1;
    
42. }
    
43. 
    
44. int nstr_lmt(const char *s, int lmt)
    
45. {
    
46.         int off;
    
47. 
    
48.         off = nstr_chr(s, 0, lmt, '\0');
    
49.         if (off == -1) {
    
50.                 off = lmt;
    
51.         }
    
52.         return off;
    
53. }
    
54. 
    
55. int nstr_nmatch(const char *s, int off, int lmt, const char *rules, int rules_len)
    
56. {
    
57.         int rules_off;
    
58.         int rules_lmt;
    
59.         int rules_next;
    
60. 
    
61.         for (rules_off = 0; rules_off < rules_len; rules_off = rules_next) {
    
62.                 rules_lmt = nstr_npbrk(rules, rules_off, rules_len, "*?", 2);
    
63.                 if (rules_lmt == -1) {
    
64.                         rules_next = rules_len;
    
65.                         rules_lmt = rules_len;
    
66.                 }else {
    
67.                         rules_next = rules_lmt + 1;
    
68.                 }
    
69.                 if (rules_off < rules_lmt) {
    
70.                         if (off + rules_lmt - rules_off <= lmt) {
    
71.                                 if (strncmp(s + off, rules + rules_off, rules_lmt - rules_off) == 0) {
    
72.                                         off += rules_lmt - rules_off;
    
73.                                 }else {
    
74.                                         return 0;
    
75.                                 }
    
76.                         }else {
    
77.                                 return 0;
    
78.                         }
    
79.                 }
    
80.                 if (rules_lmt < rules_len) {
    
81.                         if (rules[rules_lmt] == '?') {
    
82.                                 if (off + 1 <= lmt) {
    
83.                                         ++off;
    
84.                                 }else {
    
85.                                         return 0;
    
86.                                 }
    
87.                         }else { /* '*' */
    
88.                                 for(; off < lmt; ++off) {
    
89.                                         if (nstr_nmatch(s, off, lmt, rules + rules_next, rules_len - rules_next)) {
    
90.                                                 return 1;
    
91.                                         }
    
92.                                 }
    
93.                                 return off == lmt && rules_next == rules_len;
    
94.                         }
    
95.                 }
    
96.         }
    
97.         return off == lmt ? 1 : 0;
    
98. }
    
99. 
    
100. int nstr_nmatch_more(const char *s, int off, int lmt, const char *rules, int rules_len)
     
101. {
     
102.         int rules_off;
     
103.         int rules_lmt;
     
104.         int rules_next;
     
105. 
     
106.         for (rules_off = 0; rules_off < rules_len; rules_off = rules_next) {
     
107.                 rules_lmt = nstr_chr(rules, rules_off, rules_len, ';');
     
108.                 if (rules_lmt == -1) {
     
109.                         rules_lmt = rules_len;
     
110.                         rules_next = rules_len;
     
111.                 }else {
     
112.                         rules_next = rules_lmt + 1;
     
113.                 }
     
114.                 if (rules_off < rules_lmt) {
     
115.                         if (nstr_nmatch(s, off, lmt, rules + rules_off, rules_lmt - rules_off)) {
     
116.                                 return 1;
     
117.                         }
     
118.                 }
     
119.         }
     
120.         return 0;
     
121. }
     
122. 
     
123. int get_path_directory_off(const char *s, int off)
     
124. {
     
125.         if (off >= 0) {
     
126.                 if (off >= 2 && s[off - 1] == ':' && isalpha(s[off - 2])) {
     
127.                         return 2;
     
128.                 }
     
129.                 return 0;
     
130.         }
     
131.         return -1;
     
132. }
     
133. 
     
134. int get_path_filename_off(const char *s, int off)
     
135. {
     
136.         int dir_off;
     
137.         int name_off;
     
138. 
     
139.         if (off >= 0) {
     
140.                 dir_off = get_path_directory_off(s, off);
     
141.                 name_off = nstr_rchr(s, dir_off, off, PATH_SPLITTER);
     
142.                 if (name_off == -1) {
     
143.                         name_off = dir_off;
     
144.                 }
     
145.                 return name_off;
     
146.         }
     
147.         return -1;
     
148. }
     
149. 
     
150. /* enum_dir
     
151. *
     
152. * RETURN
     
153. *
     
154. *      0; SUCCESS
     
155. *     -1; ERROR: buffer overflow
     
156. *     -2; ERROR: directory not found
     
157. *     -3; ERROR: file too large
     
158. *     -4; ERROR: invalid call back function
     
159. *      #; ERROR: enum_func defined error
     
160. */
     
161. 
     
162. int enum_dir(char *s, int off, int lmt, struct file_node *node, int skip_error, int (*enum_func)(char *s, int off, int lmt, void *data), void *data)
     
163. {
     
164.         WIN32_FIND_DATA find_data;
     
165.         HANDLE hFind;
     
166.         int retval;
     
167.         int name_off;
     
168.         int name_len;
     
169. 
     
170.         retval = 0;
     
171.         if (off >= 0 && off < lmt) {
     
172.                 name_off = get_path_filename_off(s, off);
     
173.         }else {
     
174.                 retval = -1; /* ERROR: buffer overflow */
     
175.         }
     
176.         if (retval == 0) {
     
177.                 if (name_off == off) {
     
178.                         if (name_off + 3 <= lmt) {
     
179.                                 strncpy(s + name_off, "*.*", 3);
     
180.                                 off = name_off + 3;
     
181.                         }else {
     
182.                                 retval = -1; /* ERROR: buffer overflow */
     
183.                         }
     
184.                 }
     
185.         }
     
186.         if (retval == 0) {
     
187.                 if (off + 1 <= lmt) {
     
188.                         s[off] = '\0';
     
189.                 }else {
     
190.                         retval = -1; /* ERROR: buffer overflow */
     
191.                 }
     
192.         }
     
193.         if (retval == 0) {
     
194.                 hFind = FindFirstFile(s, &find_data);
     
195.                 if (hFind != INVALID_HANDLE_VALUE) {
     
196.                         do {
     
197.                                 if (strcmp(find_data.cFileName, ".") != 0 && strcmp(find_data.cFileName, "..") != 0) {
     
198.                                         name_len = nstr_lmt(find_data.cFileName, LENGTH(find_data.cFileName));
     
199.                                         if (name_off + name_len <= lmt) {
     
200.                                                 strncpy(s + name_off, find_data.cFileName, name_len);
     
201.                                                 off = name_off + name_len;
     
202.                                         }else {
     
203.                                                 retval = -1; /* ERROR: buffer overflow */
     
204.                                         }
     
205.                                         if (retval == 0) {
     
206.                                                 if (find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
     
207.                                                         if (off + 1 <= lmt) {
     
208.                                                                 s[off] = PATH_SPLITTER;
     
209.                                                                 ++off;
     
210.                                                         }else {
     
211.                                                                 retval = -1; /* ERROR: buffer overflow */
     
212.                                                         }
     
213.                                                 }
     
214.                                         }
     
215.                                         if (retval == 0) {
     
216.                                                 if (off + 1 <= lmt) {
     
217.                                                         s[off] = '\0';
     
218.                                                 }else {
     
219.                                                         retval = -1; /* ERROR: buffer overflow */
     
220.                                                 }
     
221.                                         }
     
222.                                         if (retval == 0) {
     
223.                                                 if (find_data.nFileSizeHigh == 0) {
     
224.                                                         node->size = find_data.nFileSizeLow;
     
225.                                                 }else {
     
226.                                                         retval = -3; /* ERROR: file size too large */
     
227.                                                 }
     
228.                                         }
     
229.                                         if (retval == 0) {
     
230.                                                 if (enum_func != NULL) {
     
231.                                                         retval = (*enum_func)(s, off, lmt, data);
     
232.                                                 }else {
     
233.                                                         retval = -4; /* ERROR: invalid call back function */
     
234.                                                 }
     
235.                                         }
     
236.                                         if (skip_error) {
     
237.                                                 retval = 0;
     
238.                                         }
     
239.                                 }
     
240.                         }while (retval == 0 && FindNextFile(hFind, &find_data));
     
241.                         FindClose(hFind);
     
242.                 }else {
     
243.                         retval = -2; /* ERROR: directory not found */
     
244.                 }
     
245.         }
     
246.         return retval;
     
247. }
     
248. 
     
249. struct find_param
     
250. {
     
251.         char filter[256];
     
252.         int filter_len;
     
253.         struct file_node node;
     
254.         int total_find;
     
255.         int skip_error;
     
256. };
     
257. 
     
258. int find_func(char *s, int off, int lmt, struct find_param *param)
     
259. {
     
260.         int name_off;
     
261. 
     
262.         name_off = get_path_filename_off(s, off);
     
263.         if (name_off == off) {
     
264.                 return enum_dir(s, off, lmt, &param->node, param->skip_error, find_func, param);
     
265.         }else {
     
266.                 if (nstr_nmatch_more(s, name_off, off, param->filter, param->filter_len)) {
     
267.                         printf("%s %d\n", s, param->node.size);
     
268.                         ++param->total_find;
     
269.                 }
     
270.                 return 0;
     
271.         }
     
272. }
     
273. 
     
274. int main(void)
     
275. {
     
276.         char buf[512];
     
277.         struct find_param param;
     
278.         int retval;
     
279. 
     
280.         strcpy(buf, "c:\\");
     
281.         strcpy(param.filter, "read*.txt;*.exe");
     
282.         param.filter_len = 15;
     
283.         param.total_find = 0;
     
284.         param.skip_error = 1;
     
285.         retval = enum_dir(buf, 3, 512, &param.node, param.skip_error, find_func, &param);
     
286.         printf("TOTAL FIND %d file(s)\n", param.total_find);
     
287.         if (retval) {
     
288.                 printf("ERROR %d\n", retval);
     
289.         }
     
290.         return retval;
     
291. }
     

复制代码

Herowinter

回复 25# cobras

多谢多谢，真是羡慕大神们，代码总是信手拈来，
而我每次写个新功能，都要上网找参考才能写。

lost_templar

回复 26# Herowinter


新标准里（http://www.open-std.org/jtc1/sc2 ... ers/2013/n3505.html）很快就有了，别折腾新的了 暂时先用 std:experimental:filesystem::copy_file 顶着

Herowinter

回复 27# lost_templar

多谢提供参考信息，非常好的proposal，真是期待。
但我这个是公司产品的一个小功能，马上要实现好，
等不及这个了。

   

Herowinter

@windoze@myworkstation@cobras
众位大神, 在自己实现file_copy的各种代码里发现一个很要命的bug,
假设我当前目录from, 下面有一个symbol link  
from.lnk -> .
然后我 file_copy("f1", "from.lnk/f1");
source和target其实是同一个文件,这样源文件内容就丢失了.

就算没有link 像"/test/from/f1" 和"/test//from///f1"  这2个不同的字符串
其实表示的也是相同的文件, 请问怎么做pre check, 发现传入的两个字符串
表示的其实是同一个文件.

而strace cp可以发现是同一个文件.
write(2, "`f1' and `../from.lnk/f1' are th"..., 43`f1' and `../from.lnk/f1' are the same file) = 43

爻易

复制前比较下两个文件的设备号与I节点号