linux --目录chdir函数
 
 
int chdir(const char *path );
 
 
 
说明：chdir函数用于改变当前工作目录。调用参数是指向目录的指针，调用进程需要有搜索整个目录的权限。每个进程都具有一个当前工作目录。在解析相对目录引用时，该目录是搜索路径的开始之处。如果调用进程更改了目录，则它只对该进程有效，而不能影响调用它的那个进程。在退出程序时，shell还会返回开始时的那个工作目录。
 
(1) 内核解析参数中的路径名，并确保这个路径名有效。为了做到这一点，就路径名解析而言，内核使用相同的算法。如果路径名无效，它输出错误消息并退出。
 
(2) 如果路径名有效，内核定位该目录的索引节点，并检查它的文件类型和权限位，确保目标文件是目录以及进程的所有者可以访问该目录(否则改变到新目录就没有用)。
 
(3) 内核用新目标目录的路径名和/或索引节点替换u区中当前目录路径名和/或它的索引节点号。
 
 
 
错误信息：
 
EFAULT: path 指向了非法地址
 
ENAMETOOLNG:路径过长
 
ENOENT:文件不存在
 
ENOMEM:内核内存不足
 
ENOTDIR:给出路径不是目录
 
EACCES:无访问路径中某个目录的权限
 
ELOOP：解析路径中太多的符号链接
 
EIO:发生I/O错误
 
 
 
实例1：
 
#include <unistd.h>
 
#include <iostream>
 
int main(void)
 
{
 
      long cur_path_len;
 
      char* cur_work_dir;
 
   if((cur_path_len = pathconf(".",_PC_PATH_MAX)) == -1)
 
      {
 
             perror("Couldn`t get currentworking path length");
 
             return 1;
 
      }
 
      std::cout<<"Current path lengthis "<< cur_path_len<<std::endl;
 
   if((cur_work_dir = (char*)malloc(cur_path_len)) == NULL)
 
      {
 
             perror("Couldn't allocate memoryfor the pathname");
 
             return 1;
 
      }
 
    if (getcwd(cur_work_dir,cur_path_len)==NULL)
 
{
 
             perror("Couldn`t get currentworking directory!");
 
      }
 
      else
 
{
 
             std::cout<< "Currentworking directory is"<<cur_work_dir<<std::endl;
 
      }
 
 
 
if(chdir("..") == -1)
 
      {
 
             perror("Couldn`t  change current working diretory!");
 
             return 1;
 
      }
 
   if ((getcwd(cur_work_dir,cur_path_len)) == NULL)
 
      {
 
             perror("Couldn`t get currentworking directory!");
 
             return 1;
 
      }
 
      std::cout<<"Afterchangedirectory,Current working directory is"<<cur_work_dir<<std::endl;
 
      free(cur_work_dir);
 
      return 0;
 
}

头文件：#include <unistd.h>

 用法格式：int chdir ( const char *path );

                   int fchdir ( int fd );

 

 chdir用来将当前工作目录改为参数path指定的目录。

 注意：path指针指向的参数一定是连续的路径且不能带空格，否则将会返回 -1 。

 例如：

 #include <stdio.h>

 #include <unistd.h>

 int main()//正确的

 {

          char s[]="/home";

          chdir (s);

          char xxx[1024];//获取当前目录并打印

          getcwd(xxx,1024);

          printf("The current directory is : %s\n",xxx);

 }

 打印结果为：/home

 

 int main()//错误的(1)

 {

          char s[]="/home~";//为方便我用~代表空格键

          chdir (s);

          char xxx[1024];//获取当前目录并打印

          getcwd(xxx,1024);

          printf("The current directory is : %s\n",xxx);

 }

 打印结果为：你当前运行此程序的目录

 

 int main()//错误的(2)

 {

          char s[]="echo~$HOME";//为方便我用~代表空格键

          chdir (s);

          char xxx[1024];//获取当前目录并打印

          getcwd(xxx,1024);

          printf("The current directory is : %s\n",xxx);

 }

 打印结果为：你当前运行此程序的目录

 

 fchdir 用来将当前目录改为参数fd（文件描述符）指定的目录。

            今天小编在这里给大家详细介绍下Linux里面的木操作函数，这里全都是干货哦哦哦。各位小主赶紧来这里瞧瞧哦哦哦。走过路过千万不要错过。
 

 
 
一、chdir 函数
 
       1、作用：修改当前进程的路径
 
       2、函数原型：
 
                
 
       #include <unistd.h>
             int chdir(const char *path);


 二、getcwd 函数 
 
       1、作用：获取当前进程工作目录
 
       2、函数原型：
 
            
 
       #include <unistd.h>

               char *getcwd(char *buf, size_t size);

               char *getwd(char *buf);


  
 注：一般情况下 chdir 函数 和 getcwd 函数配合在一起使用
 

 
 
chdir 函数和 getcwd 函数的运用：
 
 
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<stdio.h>


int main(int argc, char *argv[] )
{

	if( argc<2 )
	{
		perror("./a.out filepath");
		exit(1);
	}

	printf(" agrv[1] = %s\n",argv[1]);
	// 修改当前的路径
	int ret =chdir(argv[1]);
	if( ret == -1 )
	{
		perror("chdir");
		exit(1);	
	}

	// 在这里通过在改变后的目录下创建一个新的文件，来证明目录已经改变
	int fd = open("chdir.txt",O_CREAT|O_RDWR,0644);
	if( fd == -1 )
	{
		perror("open");	
		exit(1);
	}

	close(fd);

	// 获取改变目录后的目录名
	char buf[100]={0};

	getcwd(buf,sizeof(buf));
	printf("current dir: %s\n",buf);

	return 0;
}


 
  
 
 
三、rmdir 函数
 
       1、作用：删除一个目录
 
       2、函数原型：
 
 
       #include <unistd.h>

              int rmdir(const char *pathname);
 

 
 
四、mkdir 函数 
 
       1、作用：创建一个目录
 
       2、函数原型：
 

 
       #include <sys/stat.h>
       #include <sys/types.h>

           int mkdir(const char *pathname, mode_t mode);


 
五、opendir  函数 
       1、作用：打开一个目录
 
       2、函数原型：
 
       #include <sys/types.h>
       #include <dirent.h>

           DIR *opendir(const char *name);
           DIR *fdopendir(int fd);
       3、返回值： 
             (1)、DIR结构体指针，该结构是一个内部结构，保存所打开的目录的信息，作用于类似于FILE结构。
 
             (2)、函数出错，返回NULL
 
六、readdir 函数
 
       1、作用：读目录
 
       2、函数原型：
 
       #include <dirent.h>

           struct dirent *readdir(DIR *dirp);
       3、返回值： 
             返回一个记录项  
 
 
             
 
         struct dirent {
               ino_t          d_ino;       /* inode number */                  // 目录进入点的 inode
               off_t          d_off;       /* not an offset; see NOTES */      // 目录文件头开始至此目录进入点的位移
               unsigned short d_reclen;    /* length of this record */         // d_name 长度
               unsigned char  d_type;      /* type of file; not supported      // d_name 所指的文件夹 
                                              by all filesystem types */
               char           d_name[256]; /* filename */                      // 文件名
         };


         d_tyep 有 8 种类型：
          
            (1)、 DT_BLK      This is a block device.           块设备
            (2)、 DT_CHR      This is a character device.       字符设备
            (3)、 DT_DIR       This is a directory.              目录

            (4)、 DT_FIFO     This is a named pipe (FIFO).      管道
            (5)、 DT_LNK      This is a symbolic link.          软链接
            (6)、 DT_REG      This is a regular file.           普通文件
            (7)、 DT_SOCK     This is a UNIX domain socket.     套接字
            (8)、 DT_UNKNOWN     The file type is unknown.         未知类型



  
 
 七、closedir 函数
 
        1、作用：关闭一个目录
 
        2、函数原型：
 
       #include <sys/types.h>

       #include <dirent.h>

       int closedir(DIR *dirp);

        3、返回值： 
            若函数执行成功，返回0；若失败，返回 -1.
 
opendir、readdir、closedir 三个函数 的综合运用：
 
 
#include<unistd.h>
#include<dirent.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>


// 获取 root 目录下的文件个数
int get_file_count(char *root)
{
	// open dir
	DIR * dir = NULL;
	dir = opendir(root);
	if( NULL == dir )
	{
		perror("opendir");
		exit(1);
	}

	// 遍历当前打开的目录
	struct dirent* ptr = NULL;
	char path[1024]={0};
	int total = 0;
	while( (ptr = readdir(dir) )!= NULL)
	{
		// 过滤掉 . 和 ..
		if( strcmp(ptr->d_name,".") == 0 || strcmp(ptr->d_name,"..") == 0 )
		{
		
			continue;	
		}
	
		// 如果是目录，递归读目录
		if(ptr->d_type == DT_DIR)
		{
			sprintf(path,"%s/%s",root,ptr->d_name);
			total += get_file_count(path);
		}

		// 如果是普通文件
		if( ptr->d_type == DT_REG )
		{
				total++;	
		}
	}
	
	// 关闭目录
	closedir(dir);
	return total;
}

int main(int argc,char *argv[])
{
	if( argc<2 )
	{
		perror("./a.out dir\n");
		exit(1);	
	}

	// 获取文件个数
	int count =	get_file_count(argv[1]);

	printf("%s has file numbers : %d\n",argv[1],count);	
	return 0;
}


 


 
 
八、dup 和 dup2 函数
 
       1、作用：复制现有的文件描述符
 
       2、函数原型：        
 
         #include <unistd.h>

       int dup(int oldfd);
       int dup2(int oldfd, int newfd);

       3、返回值： 
              (1)、dup 返回的是文件描述符中没有被占用的
 
 
              (2)、dup2 分两种情况讨论下：
 
                      (a)、oldfd----->newfd 如果  newfd 是一个被打开的文件描述符，在拷贝前会先关掉 newfd
 
 
                      (b)、oldfd------>newfd是同一个文件描述符，不会关掉 newfd , 直接返回 oldfd
 
 
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(void)
{
	int fd =open("a.txt",O_RDWR);
	if( fd == -1 )
	{
		perror("open");
		exit(1);
	}

	printf("file open fd = %d\n",fd);

	// 找到进程文件描述符表   ======= 第一个========== 可用的文件描述符
	// 将参数指定的文件复制到该描述后          返回这个描述符

	int ret = dup(fd);
	if( fd == -1 )
	{
		perror("dup");
		exit(1);
	}

	printf(" dup fd = %d\n",ret);
	char *buf = "你是猴子请来的救兵吗？？\n";
	char *buf1 = "你大爷的，我是程序猿!!!\n";

	write(fd,buf,strlen(buf));
	write(ret,buf1,strlen(buf1));

	close(fd);
	
	return 0;
}


 
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(void)
{
	int fd =open("english.txt",O_RDWR);
	if( fd == -1 )
	{
		perror("open");
		exit(1);
	}

	int fd1 =open("a.txt",O_RDWR);
	if( fd1 == -1 )	
	{
		perror("open");
		exit(1);
	}

	printf("fd = %d\n",fd);
	printf("fd1 = %d\n",fd1);

	int ret = dup2(fd1, fd);
	if( ret == -1 )
	{	
		perror("dup2");
		exit(1);
	}

	printf(" current fd = %d\n",ret);

	char *buf = "主要看气质 !!!!!!!!!!!!!!!!!\n";

	write(fd,buf,strlen(buf));
	write(fd1,"hello world!",12);

	close(fd);
	close(fd1);

	return 0;
}


 
 
九、fcntl 函数
 
        1、作用：改变已经打开文件的属性
 
         2、函数原型：        
 
         #include <unistd.h>
      #include <fcntl.h>

       int fcntl(int fd, int cmd, ... /* arg */ );             这是一个可变长参数的函数
 
       3、功能： 
             (1)、复制一个现有的描述符--------cmd                F_DUPFD
 
 
             (2)、 获得 / 设置文件状态标价--------cmd( 参数设置如下 )             
 
 
                       (a)、F_GETFD
 
                       (b)、F_STFD
 
 
             (3)、获得 / 设置文件标记状态-------- cmd 
 
 
                       (a)、
 
                               O_RDONLY                      只读打开
 
 
                               O_WRONLY                     只写打开
 
 
                               O_RDWR                         读写打开
 
 
                               O_EXEC                           执行打开
 
 
                               O_SEARCH                      搜索打开
 
 
                               O_APPEND                      追加打开
 
 
                               O_NONBLOCK                 非阻塞模式
 
 
                       (b)、F_SETFL
 
                               O_APPEND                      
 
 
                               O_NONBLOCK                
 
 
             (4)、  获得  / 设置异步 I / O 所有权-------- cmd 
 
 
                       (a)、F_GETOWN
 
                       (b)、F_SETOWN
 
 
             (5)、获得 / 设置记录锁-------- cmd 
 
 
                       (a)、F_GETLK
 
                       (b)、F_SETLK
 
                       (c)、SETLKW
 
 
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(void)
{
	int flag;
	int fd;

	// 测试字符串

	char *p = "我们是一个由中国特使社会主义的国家！！！！！";
	char *q ="呵呵，社会主义好哇";

	// 以只写方式打开文件

	fd = open("test.txt",O_WRONLY);
	if( fd == -1 )
	{
		perror("open");
		exit(1);
	
	}

	// 输入新的内容，该内容会覆盖原来的内容
	if( write(fd,p,strlen(p)) == -1 )
	{
		perror("write");
		exit(1);
	}

	//	使用 F_GETFL 命令得到文件状态标志
	int flags = fcntl(fd,F_GETFL,0); 
	if( flags == -1 )
	{
		perror("fcntl");
		exit(1);
	}

	//	将文件状态标志添加 “追加写” 选项

	flag |= O_APPEND;

	// 将文件状态修改为追加写

	if( fcntl(fd,F_SETFL,flag) == -1 )
	{
		perror("fcntl");
		exit(1);
	}

	// 再次输入新的内容，该内容会追加到旧内容对的后面

	if( write(fd,q,strlen(q)) == -1 )
	{
		perror("write again");
		exit(1);
	}
	
	return 0;
}
 

 
 
本文介绍的所有文件操作函数的运用，代码在我的 GitHub 上，把链接分享给大家：
 
                    https://github.com/ARRAYLI/LinuxCode/tree/master
 
 
小结： 
 
        相信您看完博客收获不少吧，那就给我点赞吧，谢谢谢哦哦。
 
 

 

目录简介
 
对于linux文件目录操作函数其实使用命令就能实现，但是其实对于一些命令本质上就是调用系统函数的，比如：madir,umask,chown等命令。
 
 
获取文件信息主要函数
 
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
//不能读取软连接文件
int stat(const char *path, struct stat *buf);
//根据文件描述符读取文件信息
int fstat(int fd, struct stat *buf);
//能读取软连接文件，stat对于软连接，读取到的信息为指向的目标对象
int lstat(const char *path, struct stat *buf);
 
 
 
参数：
 
 
path: 
 文件的路径，即文件名称。
buf: 
 存储文件信息的一个结构体指针，形式如下： 
 
struct stat
{
    dev_t st_dev; //device 文件的设备编号
    ino_t st_ino; //inode 文件的i-node
    mode_t st_mode; //protection 文件的类型和存取的权限
    nlink_t st_nlink; //number of hard links 连到该文件的硬连接数目, 刚建立的文件值为1.
    uid_t st_uid; //user ID of owner 文件所有者的用户识别码
    gid_t st_gid; //group ID of owner 文件所有者的组识别码
    dev_t st_rdev; //device type 若此文件为装置设备文件, 则为其设备编号
    off_t st_size; //total size, in bytes 文件大小, 以字节计算
    unsigned long st_blksize; //blocksize for filesystem I/O 文件系统的I/O 缓冲区大小.
    unsigned long st_blocks; //number of blocks allocated 占用文件区块的个数, 每一区块大小为512 个字节.
    time_t st_atime; //time of lastaccess 文件最近一次被存取或被执行的时间, 一般只有在用mknod、utime、read、write 与tructate 时改变.
    time_t st_mtime; //time of last modification 文件最后一次被修改的时间, 一般只有在用mknod、utime 和write 时才会改变
    time_t st_ctime; //time of last change i-node 最近一次被更改的时间, 此参数会在文件所有者、组、权限被更改时更新
};
 
 
返回值
 
 
成功返回0，失败返回-1
 
 
函数的主要作用:
 
 
 
这些函数最主要的作用之一是判断文件类型，文件类型与权限存储在st_mode中，可以用以下宏获取文件类型S_ISREG(m)判断文件是否为普通文件，,参数m为结构体中的st_mode成员，若m为宏功能所指对象，则返回真值，不符合为假
 
   
S_ISDIR(m) 判断文件是否为目录文件
S_ISCHR(m) 判断文件是否为字符文件
S_ISBLK(m) 判断文件是否为块文件
S_ISFIFO(m) 判断文件是否为管道文件
S_ISLNK(m) 判断文件是否为符号链接文件
S_ISSOCK(m) 判断文件是否为套接字文件
其中st_mode也包含文件的访问权限位，每个文件（包括目录）都有九个访问权限位，如下：
 
   
S_IRUSR(m) 用户读权限
S_IWUSR(m) 用户写权限
S_IXUSR(m) 用户可执行权限
S_IRWXU(m) 用户读权限,用户写权限,用户可执行权限
S_IRGRP(m) 同组读权限
S_IWGRP(m) 同组读权限
S_IXGRP(m) 同组可执行权限
S_IRWXG(m) 同组读权限，同组读权限，同组可执行权限
S_IROTH(m) 其他读权限
S_IWOTH(m) 其他写权限
S_IXOTH(m) 其他可执行权限
S_IRWXO(m) 其他读权限，其他写权限，其他可执行权限
 
 
 
函数举例应用
 
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <stdlib.h>
int main(int argc,char *argv[])
{
    struct stat st;
    int i;
    for(i=1; i<argc; i++)
    {
        if( stat(argv[i],&st) == -1 )
        {
            perror("stat fail\n");
            exit(EXIT_FAILURE);
        }
        if( S_ISREG(st.st_mode) )
        {
            printf("regular file\n");
        }
        else if (S_ISDIR(st.st_mode) )
        {
            printf("direct file\n");
        }
        else if( S_ISCHR(st.st_mode) )
        {
            printf("char file\n");
        }
        else if( S_ISBLK(st.st_mode) )
        {
            printf("block fil\n");
        }
        else 
        {
            printf("noknw file\n");
        }
    }
    return 0;
}
 
程序运行效果：
 
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat# make
gcc -o stat stat.c
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat# ./stat /tmp
direct file
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat# ./stat ./stat.c
regular file
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat#
 
 
umask掩码函数
 
我们都知道在linux下创建一个文件或者目录之后是可以通过chmod等命令进行权限设置，来达到给当前用户、用户组用户以及其他用户分配不同的访问权限。那么，我们新创建的目录和文件本身也是有它的默认权限的，这个默认权限是什么，就是由权限掩码umask所确定的。它的功能可以说与chmod刚好相反的，代表默认拿走的也就是说不要的权限。
 
 
 
函数结构：
 
 
#include <sys/types.h>
#include <sys/stat.h>
mode_t umask(mode_t mask);
 
 
 
函数参数：
 
 
mask 
 由刚才所讲的十二个文件访问权限按位或构成的，也可以为一个四位整数,如0777，文件什么权限都没有，0000具有全部权限。
返回值 
 总是成功，没有返回失败的参数，返回值总是当前umask的值。
 
 
 
函数应用举例：
 
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
int main()
{
    umask(0);
    if( creat("a.txt",S_IRWXU|S_IRWXG) == -1 )
    {
        perror("create fail\n");
        exit(EXIT_FAILURE);
    }
    umask(0777);//此时创建的文件什么权限都没有
    system("touch bbbb");
    if( creat("b.txt",S_IRWXO|S_IRWXU) == -1 )
    {
        exit(EXIT_FAILURE);
    }
    return 0;
}
 
 
chmod，fchmod，改变文件权限
 
#include <sys/stat.h>
int chmod(const char *path, mode_t mode);
int fchmod(int fd, mode_t mode);
 
 
 
函数参数
 
 
mode 
 同上
返回值 
 成功返回0 ，出错返回-1。
 
 
 
函数应用举例
 
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc,char * argv[])
{
    struct stat st;

    if( stat(argv[1],&st) == -1 )
    {
        perror("stat fail\n");
        exit(EXIT_FAILURE);
    }
    system("ls -l ji");    
    chmod(argv[1],st.st_mode | S_IXOTH ); 
    system("ls -l ji");
    chmod(argv[1],st.st_mode&(~S_IWUSR));
    system("ls -l ji");
    return 0;
}
 
 
chown,fchown，改变文件用户ID与组ID
 
#include <unistd.h>
int chown(const char *path, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *path, uid_t owner, gid_t group);
 
 
应用举例：
 
//只有超级用户才能进行更改文件所属人
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char * argv[])
{
    struct stat st;
    if( stat(argv[1],&st) == -1 )
    {
        perror("stat fail\n");
        exit(EXIT_FAILURE);
    }
    printf("uid:%d,gid:%d\n",st.st_uid,st.st_gid);
    system("ls -l ji");
    chown(argv[1],(uid_t)0,(gid_t)0);
    stat(argv[1],&st);
    printf("uid:%d,gid:%d\n",st.st_uid,st.st_gid);
    system("ls -l ji");
    return 0;
}
 
 
mkdir 创建目录
 
#include <sys/stat.h>
 #include <sys/types.h>
 int mkdir(const char *pathname, mode_t mode);
 
 
 
参数：
 
 
pathname 
 带路径的目录名称
mode 
 创建文件的权限，与umask有关。应该至少要设置以为可执行权限位。这样才能访问该目录的内容。
 
 
返回值 
 成功返回0 ，失败返回-1.
 
 
 
应用举例：
 
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
int main()
{
    mkdir("./dir",0777);
    return 0;
}
 
代码运行效果
 
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat# make
gcc -o stat stat.c
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat# ./stat
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat# ls
dir  Makefile  stat  stat.c
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat# ls -l dir/
总用量 0
drwxrwxrwx 0 root root 4096 4月  18 14:46 dir
-rwxrwxrwx 1 root root   34 4月  18 14:02 Makefile
-rwxrwxrwx 1 root root 8600 4月  18 14:46 stat
-rwxrwxrwx 1 root root  196 4月  18 14:46 stat.c
root@DESKTOP-FR31BP0:/mnt/e/linuxcode/c/stat#
 
 
opendir打开目录
 
#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);
DIR *fdopendir(int fd);
 
 
 
功能
 
 
打开目录
 
 
参数
 
 
name；带路径的目录名
fd：目录ID
 
 
返回值
 
 
DIR*形态的目录流，接下来对目录的读取和搜索都要使用此返回值,类似文件打开会返回fd，作为open，read等的索引，这里返回的是DIR指针
 
 
 
DIR结构体
 
    struct __dirstream  
    {  
    void *__fd; /* `描述符的struct hurd_fd'指针   */  
    char *__data; /* 目录块。   */  
    int __entry_data; /* 条目号   */  
    char *__ptr; /* 当前指向该块的指针。*/  
    int __entry_ptr; /* 条目号   */  
    size_t __allocation; /* 分配给块的空间。   */  
    size_t __size; /* 块中的总有效数据。  */  
    __libc_lock_define (, __lock) /* 此结构的互斥锁。  */  
    };  
    typedef struct __dirstream DIR;  
 
readdir读取目录
 
#include <dirent.h>
struct dirent * readdir(DIR * dir);
 
 
 
功能
 
 
从指定的drip目录指针中获取一次当前目录中的文件信息
 
 
参数
 
 
dir要读的目录指针
 
 
返回值
 
 
成功则返回struct dirent结构体指针 有错误发生或读取到目录文件尾则返回NULL
 
 
 
struct dirent结构
 
    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：
    DT_BLK:块设备
    DT_CHR：字符设备
    DT_DIR：目录
    DT_LNK：软连接
    DT_FIFO：管道
    DT_REG：普通文件
    DT_SOCK：套接字文件
    DT_UNKNOWN：未知
    */
    }  
 
 
　closedir关闭目录
 
#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);
 
 
 
功能
 
 
关闭目录
 
 
参数
 
 
dirp:目录的描述指针
 
 
返回值
 
 
关闭成功则返回0,，失败返回-1,，错误原因存于errno
 
 
 
remove删除函数
 
#include <stdio.h>
int remove(const char *pathname);
 
 
 
功能
 
 
删除指定路径的文件或目录
 
 
参数
 
 
pathname:文件名或目录路径,filename为要删除的文件名，也可以为一目录。如果参数filename为一文件，则调用unlink()处理；若参数filename为目录，则调用rmdir()来处理，且该目录必须为空。
 
 
返回值
 
 
成功则返回0，失败则返回-1，错误原因存于errno
 
 
补充
 
 
int rmdir(const char *pathname);
//使用rmdir()函数时，目录必须为空，否则调用失败，函数返回-1.成功时，函数返回0
int unlink(const char *pathname);
 
 
 
小实验:读取文件夹下普通文件的内容
 
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<dirent.h>
#include<string.h>

int get_file_num(char *root)
{
    int total=0;
    DIR* dir=NULL;
    struct dirent* dirent;
    dir=opendir(root);
    if(dir==NULL)
    {
        perror("opendir");
        exit(1);
    }
    while((dirent=readdir(dir))!=NULL)
    {
        if( (strcmp(".",dirent->d_name)==0 || strcmp("..",dirent->d_name)==0) )
        {
            continue;
        }
        if( dirent->d_type == DT_REG ) 
        {
            total++;
            printf("file name is %s\n",dirent->d_name);
        }
        if( dirent->d_type == DT_DIR )
        {
            char path[1024]={0};
            sprintf(path,"%s/%s",root,dirent->d_name);
            total+=get_file_num(path);
        }
    }
    closedir(dir);
    return total;
}
int main(int argc,char *argv[])
{
    int sourcenum;
    sourcenum = get_file_num(argv[1]);
    printf("file num is %d\n",sourcenum);
    return 0;
}
 
程序运行效果：
 
root@thinkpad:/zhang/codefiles# ./a.out /root
file name is .bashrc
file name is accels
file name is user
file name is .viminfo
file name is recently-used.xbel
file name is .bash_history
file name is 9d35ab44d48248f2a61cf41d713e89a2-0
file name is .vimrc
file name is .profile
file num is 9
root@thinkpad:/zhang/codefiles# ls /root/ -a
.  ..  .bash_history  .bashrc  .cache  .config  .dbus  .local  .profile  .viminfo  .vimrc
root@thinkpad:/zhang/codefiles#