Linux C 读取文件夹下所有文件（包括子文件夹）的文件名
Linux C 下面读取文件夹要用到结构体struct dirent，在头#include <dirent.h>中，如下：
#include <dirent.h>
struct dirent
{
long d_ino; /* inode number 索引节点号 */
off_t d_off; /* offset to this dirent 在目录文件中的偏移 */
unsigned short d_reclen; /* length of this d_name 文件名长 */
unsigned char d_type; /* the type of d_name 文件类型 */
char d_name [NAME_MAX+1]; /* file name (null-terminated) 文件名，最长255字符 */
}
其中d_type表明该文件的类型：文件(8)、目录(4)、链接文件(10)等。
下面程序，递归读取某文件夹及其子文件夹下所有文件名：
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <dirent.h>
5 #include <unistd.h>
6 int readFileList(char *basePath)
7 {
8 DIR *dir;
9 struct dirent *ptr;
10 char base[1000];
11
12 if ((dir=opendir(basePath)) == NULL)
13 {
14 perror("Open dir error...");
15 exit(1);
16 }
17
18 while ((ptr=readdir(dir)) != NULL)
19 {
20 if(strcmp(ptr->d_name,".")==0 || strcmp(ptr->d_name,"..")==0) ///current dir OR parrent dir
21 continue;
22 else if(ptr->d_type == 8) ///file
23 printf("d_name:%s/%s\n",basePath,ptr->d_name);
24 else if(ptr->d_type == 10) ///link file
25 printf("d_name:%s/%s\n",basePath,ptr->d_name);
26 else if(ptr->d_type == 4) ///dir
27 {
28 memset(base,'\0',sizeof(base));
29 strcpy(base,basePath);
30 strcat(base,"/");
31 strcat(base,ptr->d_name);
32 readFileList(base);
33 }
34 }
35 closedir(dir);
36 return 1;
37 }
38
39 int main(void)
40 {
41 DIR *dir;
42 char basePath[1000];
43
44 ///get the current absoulte path
45 memset(basePath,'\0',sizeof(basePath));
46 getcwd(basePath, 999);
47 printf("the current dir is : %s\n",basePath);
48
49 ///get the file list
50 memset(basePath,'\0',sizeof(basePath));
51 strcpy(basePath,"./XL");
52 readFileList(basePath);
53 return 0;
54 }
执行输出 ：
====================下面是脚本之家========================
深入探讨:linux中遍历文件夹下的所有文件
linux C 遍历目录及其子目录
1 #include <stdio.h> 2 #include <string.h> 3 #include <stdlib.h> 4 #include <dirent.h> 5 #include <sys/stat.h> 6 #include <unistd.h> 7 #include <sys/types.h> 8 using namespace std; 9 void listDir(char *path) 10 { 11 DIR *pDir ; 12 struct dirent *ent ; 13 int i=0 ; 14 char childpath[512]; 15 16 pDir=opendir(path); 17 memset(childpath,0,sizeof(childpath)); 18 19 20 while((ent=readdir(pDir))!=NULL) 21 { 22 23 if(ent->d_type & DT_DIR) 24 { 25 26 if(strcmp(ent->d_name,".")==0 || strcmp(ent->d_name,"..")==0) 27 continue; 28 29 sprintf(childpath,"%s/%s",path,ent->d_name); 30 printf("path:%s/n",childpath); 31 32 listDir(childpath); 33 34 } 35 else 36 { 37 cout<<ent->d_name<<endl; 38 } 39 } 40 41 } 42 43 int main(int argc,char *argv[]) 44 { 45 listDir(argv[1]); 46 return 0; 47 }
Linux C ：遍历输出指定目录下的所有文件
在Linux下opendir()、readdir()和closedir()这三个函数主要用来遍历目录。在使用这三个函数前必须先包括以下两个头文件：
#include <sys/types.h>
#include <dirent.h>
opendir函数的原型为：
DIR *opendir(const char *name);
它返回一个DIR*类型，这就是一个句柄啦，你不用管它的内部结构是什么样的，只要知道这个句柄就是等一下要传给readdir()函数的参数就行了。
readdir函数的原型为：
struct dirent *readdir(DIR *dir);
看它的参数就知道该参数是opendir函数返回的句柄，而该函数的返回值是struct dirent* 类型，这里我们必须了解一下这个结构体：
struct dirent { ino_t d_ino; /* inode number */ off_t d_off; /* offset to the next dirent */ unsigned short d_reclen; /* length of this record */ unsigned char d_type; /* type of file */ char d_name[256]; /* filename */ };
这个结构体的d_name存放的就是文件的名字，这里的文件包括普通文件，目录文件等等，在linux的思想中，所有的东西都是文件。
closedir函数的原型为：
int closedir(DIR *dir);
这个函数就不用多说了，一般有开（open），就有关（close），这样的结构经常可出看到，如fopen，fclose等等。
三个函数介绍完了，直接来一个例子吧：
**********************************SearchDir.c****************************
1 #include <stdio.h> 2 #include <string.h> 3 #include <sys/types.h> 4 #include <dirent.h> 5 #include <sys/stat.h> 6 char filename[256][256]; 7 int len = 0; 8 int trave_dir(char* path, int depth) 9 { 10 DIR *d; //声明一个句柄 11 struct dirent *file; //readdir函数的返回值就存放在这个结构体中 12 struct stat sb; 13 14 if(!(d = opendir(path))) 15 { 16 printf("error opendir %s!!!\n",path); 17 return -1; 18 } 19 while((file = readdir(d)) != NULL) 20 { 21 //把当前目录.，上一级目录..及隐藏文件都去掉，避免死循环遍历目录 22 if(strncmp(file->d_name, ".", 1) == 0) 23 continue; 24 strcpy(filename[len++], file->d_name); //保存遍历到的文件名 25 //判断该文件是否是目录，及是否已搜索了三层，这里我定义只搜索了三层目录，太深就不搜了，省得搜出太多文件 26 if(stat(file->d_name, &sb) >= 0 && S_ISDIR(sb.st_mode) && depth <= 3) 27 { 28 trave_dir(file->d_name, depth + 1); 29 } 30 } 31 closedir(d); 32 return 0; 33 } 34 int main() 35 { 36 int depth = 1; 37 int i; 38 trave_dir("/usr/keygoe/ini/", depth); 39 for(i = 0; i < len; i++) 40 { 41 printf("%s\t", filename[i]); 42 } 43 printf("\n"); 44 return 0; 45 }
Linux下C语言遍历文件夹
学习了LINUX下用C语言遍历文件夹，一些心得
struct dirent中的几个成员：
d_type：4表示为目录，8表示为文件
d_reclen：16表示子目录或文件，24表示非子目录
经过本人亲自试验发现：d_reclen：16表示子目录或以.开头的隐藏文件，24表示普通文本文件，28为二进制文件，等等
d_name：目录或文件的名称
具体代码如下，仅供参考
1 #include <stdio.h> 2 #include <dirent.h> 3 #include <sys/stat.h> 4 void List(char *path) 5 { 6 struct dirent* ent = NULL; 7 DIR *pDir; 8 pDir=opendir(path); 9 while (NULL != (ent=readdir(pDir))) 10 { 11 if (ent->d_reclen==24) 12 { 13 if (ent->d_type==8) 14 { 15 printf("普通文件:%s\n", ent->d_name); 16 } 17 else 18 { 19 printf("子目录：%s\n",ent->d_name); 20 List(ent->d_name); 21 printf("返回%s\n",ent->d_name); 22 } 23 } 24 } 25 } 26 int main(int argc, char *argv[]) 27 { 28 List(argv[1]); 29 return 0; 30 }
上面函数修改后：
1 void List(char *path) 2 { 3 printf("路径为[%s]\n", path); 4 5 struct dirent* ent = NULL; 6 DIR *pDir; 7 pDir=opendir(path); 8 //d_reclen：16表示子目录或以.开头的隐藏文件，24表示普通文本文件,28为二进制文件，还有其他…… 9 while (NULL != (ent=readdir(pDir))) 10 { 11 printf("reclen=%d type=%d\t", ent->d_reclen, ent->d_type); 12 if (ent->d_reclen==24) 13 { 14 //d_type：4表示为目录，8表示为文件 15 if (ent->d_type==8) 16 { 17 printf("普通文件[%s]\n", ent->d_name); 18 } 19 } 20 else if(ent->d_reclen==16) 21 { 22 printf("[.]开头的子目录或隐藏文件[%s]\n",ent->d_name); 23 } 24 else 25 { 26 printf("其他文件[%s]\n", ent->d_name); 27 } 28 } 29 }
1 #include <stdio.h> 2 #include <dirent.h> 3 #include <sys/types.h> 4 #include <sys/stat.h> 5 6 void dir_scan(char *path, char *file); 7 int count = 0; 8 9 int main(int argc, char *argv[]) 10 { 11 struct stat s; 12 13 if(argc != 2){ 14 printf("one direction requried\n"); 15 exit(1); 16 } 17 if(lstat(argv[1], &s) < 0){ 18 printf("lstat error\n"); 19 exit(2); 20 } 21 //判断一个路径是否是目录 22 if(!S_ISDIR(s.st_mode)){ 23 printf("%s is not a direction name\n", argv[1]); 24 exit(3); 25 } 26 27 dir_scan("", argv[1]); 28 29 printf("total: %d files\n", count); 30 31 exit(0); 32 } 33 34 void dir_scan(char *path, char *file) 35 { 36 struct stat s; 37 DIR *dir; 38 struct dirent *dt; 39 char dirname[50]; 40 41 memset(dirname, 0, 50*sizeof(char)); 42 strcpy(dirname, path); 43 44 if(lstat(file, &s) < 0){ 45 printf("lstat error\n"); 46 } 47 48 if(S_ISDIR(s.st_mode)){ 49 strcpy(dirname+strlen(dirname), file); 50 strcpy(dirname+strlen(dirname), "/"); 51 if((dir = opendir(file)) == NULL){ 52 printf("opendir %s/%s error\n"); 53 exit(4); 54 } 55 if(chdir(file) < 0) { 56 printf("chdir error\n"); 57 exit(5); 58 } 59 while((dt = readdir(dir)) != NULL){ 60 if(dt->d_name[0] == '.'){ 61 continue; 62 } 63 64 dir_scan(dirname, dt->d_name); 65 } 66 if(chdir("..") < 0){ 67 printf("chdir error\n"); 68 exit(6); 69 } 70 }else{ 71 printf("%s%s\n", dirname, file); 72 count++; 73 } 74 }
linux c 下如何获得目录下的文件数目。
1 int main(int argc, char **argv) 2 { 3 DIR * pdir; 4 struct dirent * pdirent; 5 struct stat f_ftime; 6 int fcnt;/*文件数目统计*/ 7 pdir=opendir("./"); 8 if(pdir==NULL) 9 { return(-1); } 10 fcnt=0; 11 for(pdirent=readdir(pdir);pdirent!=NULL;pdirent=readdir(pdir)) 12 { 13 if(strcmp(pdirent->d_name,".")==0||strcmp(pdirent->d_name,"..")==0) continue; 14 if(stat(pdirent->d_name,&f_ftime)!=0) return -1 ; 15 if(S_ISDIR(f_ftime.st_mode)) continue; /*子目录跳过*/ 16 fcnt++; 17 printf("文件:%s\n",pdirent->d_name); 18 } 19 printf("文件总数%d\n",fcnt); 20 closedir(pdir); 21 return 0; 22 } 23 #include <unistd.h> 24 #include <stdio.h> 25 #include <dirent.h> 26 #include <string.h> 27 #include <sys/stat.h> 28 29 void printdir(char *dir, int depth) 30 { 31 DIR *dp; 32 struct dirent *entry; 33 struct stat statbuf; 34 35 if((dp = opendir(dir)) == NULL) { 36 fprintf(stderr, "cannot open directory: %s\n ", dir); 37 return; 38 } 39 chdir(dir); 40 while((entry = readdir(dp)) != NULL) { 41 lstat(entry-> d_name,&statbuf); 42 if(S_ISDIR(statbuf.st_mode)) { 43 /**//* Found a directory, but ignore . and .. */ 44 if(strcmp( ". ",entry-> d_name) == 0 || 45 strcmp( ".. ",entry-> d_name) == 0) 46 continue; 47 printf( "%*s%s/\n ",depth, " ",entry-> d_name); 48 /**//* Recurse at a new indent level */ 49 printdir(entry-> d_name,depth+4); 50 } 51 else printf( "%*s%s\n ",depth, " ",entry-> d_name); 52 } 53 chdir( ".. "); 54 closedir(dp); 55 } 56 57 /**//* Now we move onto the main function. */ 58 59 int main(int argc, char* argv[]) 60 { 61 char *topdir, pwd[2]= ". "; 62 if (argc != 2) 63 topdir=pwd; 64 else 65 topdir=argv[1]; 66 67 printf( "Directory scan of %s\n ",topdir); 68 printdir(topdir,0); 69 printf( "done.\n "); 70 71 exit(0); 72 }
关于readdir返回值中struct dirent.d_type的取值问题：
unsigned char d_type
This is the type of the file, possibly unknown. The following constants are defined for its value:
DT_UNKNOWN
The type is unknown. Only some filesystems have full support to return the type of the file, others might always return this value.
类型未知。少数文件系统会出现此函数不支持的文件类型，另一些则总是返回这个值。译者注：总之这个值是为了应对不兼容的文件系统而设置的。
DT_REG
A regular file.
常规文件
DT_DIR
A directory.
目录
DT_FIFO
A named pipe, or FIFO. See FIFO Special Files.
一个命名管道，或FIFO。
DT_SOCK
A local-domain socket.
套接字
DT_CHR
A character device.
字符设备
DT_BLK
A block device.
块设备
DT_LNK
A symbolic link.
符号链接
具体数值
enum
{
DT_UNKNOWN = 0,
# define DT_UNKNOWN DT_UNKNOWN
DT_FIFO = 1,
# define DT_FIFO DT_FIFO
DT_CHR = 2,
# define DT_CHR DT_CHR
DT_DIR = 4,
# define DT_DIR DT_DIR
DT_BLK = 6,
# define DT_BLK DT_BLK
DT_REG = 8,
# define DT_REG DT_REG
DT_LNK = 10,
# define DT_LNK DT_LNK
DT_SOCK = 12,
# define DT_SOCK DT_SOCK
DT_WHT = 14
# define DT_WHT DT_WHT
};
只用dirent存在问题：
部分linux文件系统，例如xfs不支持d_type,当你用d_type时，所有文件/目录的d_type会一直为空，即0（UNKNOWN）,无法判断文件类型。所以需要stat
