Linux C ：遍历输出指定目录下的所有文件, 及st_mode判断文件类型

一. 遍历输出指定目录下的所有文件

在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****************************************************
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
char filename[256][256];
int len = 0;
int trave_dir(char* path, int depth)
{
    DIR *d;  //声明一个句柄
    struct dirent *file;  //readdir函数的返回值就存放在这个结构体中
    struct stat sb;    
    
    if(!(d = opendir(path)))
    {
        printf("error opendir %s!!!/n",path);
        return -1;
    }
    while((file = readdir(d)) != NULL)
    {
         //把当前目录.，上一级目录..及隐藏文件都去掉，避免死循环遍历目录
        if(strncmp(file->d_name, ".", 1) == 0)
            continue;
        strcpy(filename[len++], file->d_name);  //保存遍历到的文件名
         //判断该文件是否是目录，及是否已搜索了三层，这里我定义只搜索了三层目录，太深就不搜了，省得搜出太多文件
        if(lstat(file->d_name, &sb) >= 0 && S_ISDIR(sb.st_mode) && depth <= 3)
        {
            trave_dir(file->d_name, depth + 1);
        }
    }
    closedir(d);
    return 0;
}
int main()
{
    int depth = 1;
    int i;
    trave_dir("/usr/keygoe/ini/", depth);
    for(i = 0; i < len; i++)
    {
        printf("%s/t", filename[i]);
    }
    printf("/n");
    return 0;
}

*****************************************************************************************************************

//
Linux下C语言遍历文件夹
学习了LINUX下用C语言遍历文件夹，一些心得
struct dirent中的几个成员：
d_type：4表示为目录，8表示为文件
d_reclen：16表示子目录或文件，24表示非子目录
经过本人亲自试验发现：d_reclen：16表示子目录或以.开头的隐藏文件，24表示普通文本文件，28为二进制文件，等等
d_name：目录或文件的名称
具体代码如下，仅供参考
#include <stdio.h>
#include <dirent.h>
#include <sys/stat.h>
void List(char *path)
{
     struct dirent* ent = NULL;
     DIR *pDir;
     pDir=opendir(path);
     while (NULL != (ent=readdir(pDir)))
     {
         if (ent->d_reclen==24)
         {
             if (ent->d_type==8)
             {
                 printf("普通文件:%s\n", ent->d_name);
             }
             else
             {
                 printf("子目录：%s\n",ent->d_name);
                 List(ent->d_name);
                 printf("返回%s\n",ent->d_name);
             }
         }
     }
}

int main(int argc, char *argv[])
{
      List(argv[1]);
      return 0;
}
上面函数修改后：
void List(char *path)
{
     printf("路径为[%s]\n", path);
     
     struct dirent* ent = NULL;
     DIR *pDir;
     pDir=opendir(path);
     //d_reclen：16表示子目录或以.开头的隐藏文件，24表示普通文本文件,28为二进制文件，还有其他……
     while (NULL != (ent=readdir(pDir)))
     {
         printf("reclen=%d    type=%d\t", ent->d_reclen, ent->d_type);
         if (ent->d_reclen==24)
         {    
             //d_type：4表示为目录，8表示为文件
             if (ent->d_type==8)
             {
                 printf("普通文件[%s]\n", ent->d_name);
             }
         }
         else if(ent->d_reclen==16)
         {
             printf("[.]开头的子目录或隐藏文件[%s]\n",ent->d_name);
         }
         else
         {
             printf("其他文件[%s]\n", ent->d_name);
         }
     }
}
转CU，地址：
http://blog.chinaunix.net/u/29024/showart_484896.html
#include   <stdio.h>   
#include   <dirent.h>   
#include   <sys/types.h>   
#include   <sys/stat.h>    
void dir_scan(char   *path,   char   *file);   
int count = 0;   
int main(int   argc,   char   *argv[])   
{   
                   struct   stat   s;   
     
                   if(argc   !=   2){   
                                   printf("one   direction   requried\n");   
                                   exit(1);   
                   }   
                   if(lstat(argv[1],   &s)   <   0){   
                                   printf("lstat   error\n");   
                                   exit(2);   
                   }   
                  //判断一个路径是否是目录
                   if(!S_ISDIR(s.st_mode)){   
                                   printf("%s   is   not   a   direction   name\n",   argv[1]);   
                                   exit(3);   
                   }   
                   dir_scan("",   argv[1]);   
     
                   printf("total:   %d   files\n",   count);   
     
                   exit(0);   
}   
void   dir_scan(char   *path,   char   *file)   
{   
                   struct   stat   s;   
                   DIR           *dir;   
                   struct   dirent   *dt;   
                   char   dirname[50];      
                   memset(dirname,   0,   50*sizeof(char));   
                   strcpy(dirname,   path);    
                   if(lstat(file,   &s)   <   0){   
                                   printf("lstat   error\n");   
                   }   
                   if(S_ISDIR(s.st_mode)){   
                                   strcpy(dirname+strlen(dirname),   file);   
                                   strcpy(dirname+strlen(dirname),   "/");   
                                   if((dir   =   opendir(file))   ==   NULL){   
                                                   printf("opendir   %s/%s   error\n");   
                                                   exit(4);   
                                   }   
                                   if(chdir(file)   <   0)   {   
                                                   printf("chdir   error\n");   
                                                   exit(5);   
                                   }   
                                   while((dt   =   readdir(dir))   !=   NULL){   
                                                   if(dt->d_name[0]   ==   '.'){   
                                                                   continue;   
                                                   }   
     
                                                   dir_scan(dirname,   dt->d_name);   
                                   }   
                                   if(chdir("..")   <   0){   
                                                   printf("chdir   error\n");   
                                                   exit(6);   
                                   }   
                   }else{   
                                   printf("%s%s\n",   dirname,   file);   
                                   count++;   
                   }   
}
linux c 下如何获得目录下的文件数目。
int main(int argc, char **argv)
{    
      DIR  * pdir;
     struct dirent * pdirent;
     struct stat f_ftime;
     int fcnt;/*文件数目统计*/
      pdir=opendir("./");
     if(pdir==NULL)
     {      return(-1);    }
      fcnt=0;
     for(pdirent=readdir(pdir);pdirent!=NULL;pdirent=readdir(pdir))
     {
       if(strcmp(pdirent->d_name,".")==0||strcmp(pdirent->d_name,"..")==0) continue;
       if(stat(pdirent->d_name,&f_ftime)!=0) return -1 ;
       if(S_ISDIR(f_ftime.st_mode)) continue; /*子目录跳过*/
        fcnt++;  
       printf("文件:%s\n",pdirent->d_name);
     }
     printf("文件总数%d\n",fcnt);
      closedir(pdir);
     return 0; 
}

#include <unistd.h>  
#include <stdio.h>  
#include <dirent.h>  
#include <string.h>  
#include <sys/stat.h>   
void printdir(char *dir, int depth) 
{ 
          DIR *dp; 
          struct dirent *entry; 
          struct stat statbuf; 
   
          if((dp = opendir(dir)) == NULL) { 
                      fprintf(stderr, "cannot open directory: %s\n ", dir); 
                      return; 
          } 
          chdir(dir); 
          while((entry = readdir(dp)) != NULL) { 
                      lstat(entry-> d_name,&statbuf); 
                      if(S_ISDIR(statbuf.st_mode)) { 
                                  /**//* Found a directory, but ignore . and .. */ 
                                  if(strcmp( ". ",entry-> d_name) == 0 || 
                                              strcmp( ".. ",entry-> d_name) == 0) 
                                              continue; 
                                  printf( "%*s%s/\n ",depth, " ",entry-> d_name); 
                                  /**//* Recurse at a new indent level */ 
                                  printdir(entry-> d_name,depth+4); 
                      } 
                      else printf( "%*s%s\n ",depth, " ",entry-> d_name); 
          } 
          chdir( ".. "); 
          closedir(dp); 
} 
   
/**//*    Now we move onto the main function.    */ 
int main(int argc, char* argv[]) 
{ 
          char *topdir, pwd[2]= ". "; 
          if (argc != 2) 
                      topdir=pwd; 
          else 
                      topdir=argv[1]; 
   
          printf( "Directory scan of %s\n ",topdir); 
          printdir(topdir,0); 
          printf( "done.\n "); 
   
          exit(0); 
}

二. st_mode判断文件类型

Linux中用st_mode判断文件类型

在Linux中，可以利用stat()函数来获取一个文件的状态

[cpp]  view plain copy

1. #include <sys/stat.h>  
2. #include <unistd.h>  
3.   
4. int stat(const char *file_name, struct stat *buf);  

这个函数执行成功返回0，失败返回-1。取得的文件状态存放在buf指针指向的struct stat结构提中， struct stat的定义如下：

[cpp]  view plain copy

1. struct stat    
2. {    
3.     dev_t       st_dev;     /* ID of device containing file -文件所在设备的ID*/    
4.     ino_t       st_ino;     /* inode number -inode节点号*/  
5.     mode_t      st_mode;    /* 文件的类型和存取的权限*/    
6.     nlink_t     st_nlink;   /* number of hard links -链向此文件的连接数(硬连接)*/    
7.     uid_t       st_uid;     /* user ID of owner -user id*/    
8.     gid_t       st_gid;     /* group ID of owner - group id*/    
9.     dev_t       st_rdev;    /* device ID (if special file) -设备号，针对设备文件*/    
10.     off_t       st_size;    /* total size, in bytes -文件大小，字节为单位*/    
11.     blksize_t   st_blksize; /* blocksize for filesystem I/O -系统块的大小*/    
12.     blkcnt_t    st_blocks;  /* number of blocks allocated -文件所占块数*/    
13.     time_t      st_atime;   /* time of last access -最近存取时间*/    
14.     time_t      st_mtime;   /* time of last modification -最近修改时间*/    
15.     time_t      st_ctime;   /* time of last status change - */    
16. };    

其中， st_mode这个变量用来判断文件类型。

st_mode是用特征位来表示文件类型的，特征位的定义如下：

[cpp]  view plain copy

1. S_IFMT      0170000     文件类型的位遮罩  
2. S_IFSOCK    0140000     socket  
3. S_IFLNK     0120000     符号链接(symbolic link)  
4. S_IFREG     0100000     一般文件  
5. S_IFBLK     0060000     区块装置(block device)  
6. S_IFDIR     0040000     目录  
7. S_IFCHR     0020000     字符装置(character device)  
8. S_IFIFO     0010000     先进先出(fifo)  
9. S_ISUID     0004000     文件的(set user-id on execution)位  
10. S_ISGID     0002000     文件的(set group-id on execution)位  
11. S_ISVTX     0001000     文件的sticky位  
12. S_IRWXU     00700       文件所有者的遮罩值(即所有权限值)  
13. S_IRUSR     00400       文件所有者具可读取权限  
14. S_IWUSR     00200       文件所有者具可写入权限  
15. S_IXUSR     00100       文件所有者具可执行权限  
16. S_IRWXG     00070       用户组的遮罩值(即所有权限值)  
17. S_IRGRP     00040       用户组具可读取权限  
18. S_IWGRP     00020       用户组具可写入权限  
19. S_IXGRP     00010       用户组具可执行权限  
20. S_IRWXO     00007       其他用户的遮罩值(即所有权限值)  
21. S_IROTH     00004       其他用户具可读取权限  
22. S_IWOTH     00002       其他用户具可写入权限  
23. S_IXOTH     00001       其他用户具可执行权限  
24. 摘自《Linux C 函数库参考手册》  

判断文件类型时，用对文件的st_mode的值与上面给出的值相与，再比较。比如：

[cpp]  view plain copy

1. #include <sys/stat.h>  
2. #include <unistd.h>  
3. #include <stdio.h>  
4.   
5. int main()  
6. {  
7.     int abc;  
8.     struct stat buf;  
9.     stat("/home", &buf);  
10.     abc = buf.st_mode & S_IFDIR;//与对应的标志位相与  
11.     if(abc == S_IFDIR)          //结果与标志位比较  
12.         printf("It's a directory.\n");  
13.     return 0;  
14. }  

运行结果：

It's a directory.

其实还有一个简单的方法，文件类型在POSIX中定义了检查这些类型的宏定义：

[cpp]  view plain copy

1. S_ISLINGK(st_mode)      判断是否位符号链接  
2. S_ISREG(st_mode)        是否为一般文件  
3. S_ISDIR(st_mode)        是否为目录  
4. S_ISCHR(st_mode)        是否位字符装置文件  
5. S_ISBLK(s3e)            是否先进先出  
6. S_ISSOCK(st_mode)       是否为socket  

可以根据这些函数的返回值判断，如果是，则返回1。（我试了一下，好像是这样的）