C++遍历文件目录_c++ 遍历目录

综述

C++程序遍历目录是十分频繁的需求。比如有时候需要设计一个批处理程序，帮助我们完成机械重复的工作。

代码

#include <iostream>
#include<fstream>
#include <sys/dir.h>
#include <sys/stat.h>
using namespace std;

bool isDir(const char* path);
void myFind(const string& filename, const string& tofind);
void findInDir(const char *path, const string& tofind);
void findInDir(const char *path, const string& tofind, int recursive);



void myFind(const string& filename, const string& tofind)
{
    ifstream fin(filename.c_str(),ios_base::binary);
    string str(1024*1024*2,0);
    fin.read(&str[0],2*1024*1024);
    fin.close();

    string::size_type beg = 0;
    string::size_type pos = -1;
    string::size_type find_size = tofind.size();
    if(0 == find_size)
    {
        cout << "no such file or no content" << endl;
        return;
    }

    unsigned count = 0;
    while((pos=str.find(tofind,beg))!=string::npos)
    {
        beg=pos+find_size;
        count++;
    }
//    cout << "find matched number:" << count << endl;
}
//遍历文件夹的驱动函数
void findInDir(const char *path, const string& tofind)
{
    unsigned long len;
    char temp[256];
    //去掉末尾的'/'
    len = strlen(path);
    strcpy(temp, path);
    if(temp[len - 1] == '/') temp[len -1] = '\0';

    if(isDir(temp))
    {
        //处理目录
        int recursive = 1;
        findInDir(temp, tofind, recursive);
    }
    else   //输出文件
    {
        myFind(path, tofind);
    }
}


//字符串分割函数
std::vector<std::string> split(std::string str,std::string pattern)
{
    std::string::size_type pos;
    std::vector<std::string> result;
    str+=pattern;//扩展字符串以方便操作
    int size=str.size();

    for(int i=0; i<size; i++)
    {
        pos=str.find(pattern,i);
        if(pos<size)
        {
            std::string s=str.substr(i,pos-i);
            result.push_back(s);
            i=pos+pattern.size()-1;
        }
    }
    return result;
}



bool isDir(const char* path)
{
    struct stat st;
    lstat(path, &st);
    return 0 != S_ISDIR(st.st_mode);
}

vector<string> MA_con;
vector<string> Connection_con;


//遍历文件夹de递归函数
string currentpath_lastname;
void findInDir(const char *path, const string& tofind, int recursive)
{
    DIR *pdir;
    struct dirent *pdirent;
    char temp[256];
    try {
        pdir = opendir(path);
    }
    catch(const char *str)
    {printf("failed open dir");}

    if(pdir)
    {
        while((pdirent = readdir(pdir)))
        {
            //跳过"."和".."
            if(strcmp(pdirent->d_name, ".") == 0
               || strcmp(pdirent->d_name, "..") == 0)
                continue;
            sprintf(temp, "%s/%s", path, pdirent->d_name);

            //当temp为目录并且recursive为1的时候递归处理子目录
            if(isDir(temp) && recursive)
            {
                findInDir(temp, tofind, recursive);
            }
            else
            {
                string temppath(temp);
                vector<string>rescon  = split(temppath,"/");
                currentpath_lastname = rescon[rescon.size()-1];
                if(currentpath_lastname[0]=='M'&& currentpath_lastname[1]=='A'){
//                    cout << "processing the MA" <<temppath <<endl;
                    MA_con.push_back(currentpath_lastname);
                }
                if(currentpath_lastname[0]=='C'&& currentpath_lastname[1]=='o'){
//                    cout << "processing the Connection" <<temppath <<endl;
                    Connection_con.push_back(currentpath_lastname);

                }
                myFind(temp, tofind);
            }
        }
    }
    else
    {
        printf("opendir error:%s\n", path);
    }
    closedir(pdir);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

参考博客