vc++编写文件搜索类

阿杰

一个文件搜索类，可以递归查找和模糊匹配的，花了点时间写了下，用一个链表保存文件信息。最后用releasefile释放这个链表。

1. 
   
2. #include <iostream>
   
3. #include "windows.h"
   
4. using namespace std;
   
5. class file{
   
6. public:
   
7.         file(char *,int);
   
8.         ~file();
   
9.         void getfilename(char*);
   
10.         void getdir(char*);
    
11.         void getfullname(char*);
    
12.         void getext(char*);
    
13.         void getname(char*);
    
14.         int gettype();
    
15.         file *next;
    
16.         int getlength();
    
17. private:
    
18.         char *fullname;
    
19.         int type;
    
20. };
    
21. class filesearch{
    
22. public:
    
23. file*        search(char *,char *,int,int);
    
24. file*        subfolders(char *);
    
25. file* subfiles(char *);
    
26. file*  subff(char *);
    
27. void   releasefile(file*);
    
28. };
    
29. file::file(char *path,int t){
    
30.         fullname=new char[strlen(path)+1];
    
31.         strcpy(fullname,path);
    
32.         type=t;
    
33. }
    
34. file::~file(){
    
35.         delete[] fullname;
    
36. }
    
37. void file::getfilename(char* name){
    
38.         int i=strlen(fullname)-1;
    
39.         while(i>=0){
    
40.                 if(fullname[i]=='\\' || fullname[i]=='/'){
    
41.                         strcpy(name,fullname+i+1);
    
42.                         return;
    
43.                 }
    
44.                 i--;
    
45.         }
    
46.         strcpy(name,"");
    
47. }
    
48. void file::getdir(char* dir){
    
49.         char *s=new char[strlen(fullname)+1];
    
50.         getfilename(s);
    
51.         int c=strlen(fullname)-strlen(s)-1;
    
52.         strncpy(dir,fullname,c);
    
53.         dir[c]=0;
    
54.         delete[] s;
    
55. }
    
56. void file::getfullname(char* name){
    
57.         strcpy(name,fullname);
    
58. }
    
59. void file::getext(char* ext){
    
60.         char *s=new char[strlen(fullname)+1];
    
61.         getfilename(s);
    
62.         int i=strlen(s)-1;
    
63.         while(i>=0){
    
64.                 if(s[i]=='.'){
    
65.                         strcpy(ext,s+i+1);
    
66.                         return;
    
67.                 }
    
68.                 i--;
    
69.         }
    
70.         strcpy(ext,"");
    
71.         delete[] s;
    
72. }
    
73. void file::getname(char* name){
    
74.         int i=strlen(fullname)-1;
    
75.         while(i>=0){
    
76.                 if(fullname[i]=='\\' || fullname[i]=='/'){
    
77.                         i++;
    
78.                         int i1=0;
    
79.                         while(fullname[i]){
    
80.                        
    
81.                                 if(fullname[i]=='.'){
    
82.                                         name[i1]=0;
    
83.                                         return;
    
84.                                 }else{
    
85.                                         name[i1++]=fullname[i];
    
86.                                 }
    
87.                                 i++;
    
88.                         }
    
89.                         name[i1]=0;
    
90.                         return;
    
91.                        
    
92.                 }
    
93.                 i--;
    
94.         }
    
95.         strcpy(name,"");
    
96. }
    
97. int file::gettype(){
    
98. return type;
    
99. }
    
100. int file::getlength(){
     
101.         return strlen(fullname);
     
102. }
     
103. file* filesearch::subff(char *path){
     
104.         WIN32_FIND_DATA data;
     
105.         char tpath[MAX_PATH];
     
106.         strcpy(tpath,path);
     
107.         strcat(tpath,"\\*");
     
108.         HANDLE h=FindFirstFile(tpath,&data);
     
109.         FindNextFile(h,&data);
     
110.                 file *ff=0;
     
111.                 file *head=0;
     
112.                 while(FindNextFile(h,&data)){
     
113.                         char name[MAX_PATH];
     
114.                         strcpy(name,path);
     
115.                         strcat(name,"\");
     
116.                         strcat(name,data.cFileName);
     
117.                         file* ff1=new file(name,data.dwFileAttributes);
     
118.                         ff1->next=0;
     
119.                         if(ff!=0){
     
120.                                 ff->next=ff1;
     
121.                                 ff=ff1;
     
122.                         }else{
     
123.                                 ff=ff1;
     
124.                                 head=ff;
     
125.                         }
     
126.                        
     
127.                         if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){
     
128.                                 file* ff2=subff(name);
     
129.                                 if(ff2){
     
130.                                 ff1->next=ff2;
     
131.                                 while(ff2->next!=0){
     
132.                                         ff2=ff2->next;
     
133.                                 }
     
134.                                 ff=ff2;
     
135.                                 }
     
136.                         }
     
137.                        
     
138.                 }
     
139.                 FindClose(h);
     
140.                 return head;
     
141. }
     
142. void filesearch::releasefile(file* f){
     
143.         while(f){
     
144.                 file *f1=f;
     
145.                 f=f->next;
     
146.                 delete f1;
     
147.         }
     
148. }
     
149. file *filesearch::search(char *dir,char *name,int r,int reg){
     
150. file *f=subff(dir);
     
151. file *f1=0;
     
152. file *head=0;
     
153. if(f){
     
154.        
     
155.         if(r){
     
156.                 if(reg){
     
157.                         while(f){
     
158.                                 char a[MAX_PATH];
     
159.                                 f->getfilename(a);
     
160.                                 if(strstr(a,name)){
     
161.                                         char fullname[MAX_PATH];
     
162.                                         f->getfullname(fullname);
     
163.                                         file *ff2=new file(fullname,f->gettype());
     
164.                                         ff2->next=0;
     
165.                                         if(f1){
     
166.                                                 f1->next=ff2;
     
167.                                                 f1=ff2;
     
168.                                         }else{
     
169.                                                 f1=ff2;
     
170.                                                 head=f1;
     
171.                                         }
     
172.                                 }
     
173.                                 f=f->next;
     
174.                         }
     
175.                 }else{
     
176.                         while(f){
     
177.                                 char a[MAX_PATH];
     
178.                                 f->getfilename(a);
     
179.                                 if(stricmp(a,name)==0){
     
180.                                         char fullname[MAX_PATH];
     
181.                                         f->getfullname(fullname);
     
182.                                         file *ff2=new file(fullname,f->gettype());
     
183.                                         ff2->next=0;
     
184.                                         if(f1){
     
185.                                                 f1->next=ff2;
     
186.                                                 f1=ff2;
     
187.                                         }else{
     
188.                                                 f1=ff2;
     
189.                                                 head=f1;
     
190.                                         }
     
191.                                 }
     
192.                                 f=f->next;
     
193.                         }
     
194.                 }
     
195.         }else{
     
196.                 if(reg){
     
197.                         while(f){
     
198.                                 char a[MAX_PATH],d[MAX_PATH];
     
199.                                 f->getfilename(a);
     
200.                                 f->getdir(d);
     
201.                                 if(strstr(a,name) && stricmp(d,dir)==0){
     
202.                                         char fullname[MAX_PATH];
     
203.                                         f->getfullname(fullname);
     
204.                                         file *ff2=new file(fullname,f->gettype());
     
205.                                         ff2->next=0;
     
206.                                         if(f1){
     
207.                                                 f1->next=ff2;
     
208.                                                 f1=ff2;
     
209.                                         }else{
     
210.                                                 f1=ff2;
     
211.                                                 head=f1;
     
212.                                         }
     
213.                                 }
     
214.                                 f=f->next;
     
215.                         }
     
216.                 }else{
     
217.                         while(f){
     
218.                                 char a[MAX_PATH],d[MAX_PATH];
     
219.                                 f->getfilename(a);
     
220.                                 f->getdir(d);
     
221.                                 if(stricmp(a,name)==0 && stricmp(d,dir)==0){
     
222.                                         char fullname[MAX_PATH];
     
223.                                         f->getfullname(fullname);
     
224.                                         file *ff2=new file(fullname,f->gettype());
     
225.                                         ff2->next=0;
     
226.                                         if(f1){
     
227.                                                 f1->next=ff2;
     
228.                                                 f1=ff2;
     
229.                                         }else{
     
230.                                                 f1=ff2;
     
231.                                                 head=f1;
     
232.                                         }
     
233.                                 }
     
234.                                 f=f->next;
     
235.                         }
     
236.                 }
     
237.         }
     
238.         releasefile(f);
     
239. }
     
240. return head;
     
241. }
     
242. file* filesearch::subfiles(char *dir){
     
243.         file *f=subff(dir);
     
244.         file *head=0;
     
245.         file *f1=0;
     
246.         while(f){
     
247.                 char name[MAX_PATH],d[MAX_PATH];
     
248.                 f->getfullname(name);
     
249.                 f->getdir(d);
     
250.                 if(stricmp(dir,d)==0 && !(f->gettype() & FILE_ATTRIBUTE_DIRECTORY)){
     
251.                         file *ff2=new file(name,f->gettype());
     
252.                         ff2->next=0;
     
253.                         if(f1){
     
254.                                 f1->next=ff2;
     
255.                                 f1=ff2;
     
256.                         }else{
     
257.                                 f1=ff2;
     
258.                                 head=f1;
     
259.                         }
     
260.                 }
     
261.                 f=f->next;
     
262.         }
     
263.         releasefile(f);
     
264.         return head;
     
265. }
     
266. file* filesearch::subfolders(char *dir){
     
267.         file *f=subff(dir);
     
268.         file *head=0;
     
269.         file *f1=0;
     
270.         while(f){
     
271.                 char name[MAX_PATH],d[MAX_PATH];
     
272.                 f->getfullname(name);
     
273.                 f->getdir(d);
     
274.                 if(stricmp(dir,d)==0 && (f->gettype() & FILE_ATTRIBUTE_DIRECTORY)){
     
275.                         file *ff2=new file(name,f->gettype());
     
276.                         ff2->next=0;
     
277.                         if(f1){
     
278.                                 f1->next=ff2;
     
279.                                 f1=ff2;
     
280.                         }else{
     
281.                                 f1=ff2;
     
282.                                 head=f1;
     
283.                         }
     
284.                 }
     
285.                 f=f->next;
     
286.         }
     
287.         releasefile(f);
     
288.         return head;
     
289. }
     
290. 
     

复制代码

给个实例：

main(){
filesearch f;
file* ff=f.subfolders("d:\\test");

file* head=ff;
while(ff){
char a[255];
ff->getfullname(a);
cout<<a<<endl;
ff=ff->next;
}
f.releasefile(head);
}

本帖来自：http://blog.csdn.net/sx1989827/archive/2010/08/25/5837119.aspx

upring

c语言的代码就是长 嘿嘿