精华内容
下载资源
问答
  • dirent.h头文件

    2017-11-02 10:04:53
    <dirent.h>是一个应用程序接口,主要用于文件系统的目录读取操作,主要提供了几个目录数据读取函数,参见opengroup.org<dirent.h> int closedir(DIR *);//关闭目录 DIR *opendir(const char *);//打开目录 struct ...
  • dirent.h 头文件

    2019-09-29 20:41:47
    解决vs工程报错“无法打开包括文件:“dirent.h””,将该文件复制在工程目录下,或者直接复制在 (vs库目录) 例如我的目录:C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include
  • dirent.h,用于读取文件的头文件,相当于Linux的移植版
  • 适用于VS2010、vs2013开发的dirent.h头文件,下载解压可以直接提取头文件。
  • dirent.h:opendir()函数—打开目录函数,readdir()函数—读取目录函数,所需的头文件;dirent.h文件在压缩包的 include 目录中,examples目录中为一些使用示例。
  • dirent.h使用详解

    2021-09-28 10:53:32
    dirent.h> DIR *opendir(const char *dirname); struct dirent *readdir(DIR *dirp); int closedir(DIR *dirp); opendir用于打开目录,是类似于流的那种方式,返回一个指向DIR结构体的指针,参数*dirname是一个...

    Linux下遍历目录的方法,打开目录,读取目录,关闭目录
    opendir -> readdir -> closedir
    函数原型:

    #include <dirent.h>
    DIR *opendir(const char *dirname);
    struct dirent *readdir(DIR *dirp);
    int closedir(DIR *dirp);
    

    opendir用于打开目录,是类似于流的那种方式,返回一个指向DIR结构体的指针,参数*dirname是一个字符数组或者字符串常量;

    readdir函数用于读取目录,只有一个参数,就是opendir返回的结构体指针

    closedir用于关闭DIR结构体指针

    DIR结构体定义:

    struct __dirstream   
    {   
        void *__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;  
    

    dirent结构体定义:

    struct dirent
    {
    long d_ino;                     
    off_t d_off;                    
    unsigned short d_reclen;        
    char d_name [NAME_MAX+1];       
    }
    

    d_ino存放的是该文件的索引节点号inode;
    d_off 是文件在目录中的编移,具体是什么意思也不是很明白,很少用到它,
    基本上就是用到d_name
    short d_reclen是这个文件的长度,需要注意的是这里的长度并不是指文件大小,因为大小和长度是两回回事了,你可以用lseek将文件长度移得很长,但大小其实还是那么大。
    最后一个,文件名称。

    通过readdir函数读取到的文件名存储在结构体dirent的d_name成员中,而函数
    int stat(const char *file_name, struct stat *buf);的作用就是获取文件名为d_name的文件的详细信息,存储在stat结构体中。
    stat结构体定义:

    struct stat {   
            mode_t     st_mode;       //文件访问权限   
            ino_t      st_ino;       //索引节点号   
            dev_t      st_dev;        //文件使用的设备号   
            dev_t      st_rdev;       //设备文件的设备号   
            nlink_t    st_nlink;      //文件的硬连接数   
            uid_t      st_uid;        //所有者用户识别号   
            gid_t      st_gid;        //组识别号   
            off_t      st_size;       //以字节为单位的文件容量   
            time_t     st_atime;      //最后一次访问该文件的时间   
            time_t     st_mtime;      //最后一次修改该文件的时间    
            time_t     st_ctime;      //最后一次改变该文件状态的时间   
            blksize_t st_blksize;    //包含该文件的磁盘块的大小   
            blkcnt_t   st_blocks;     //该文件所占的磁盘块   
          };  
    

    事例:

    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <dirent.h>
    void print_usage(void);
    
    void print_usage(void)
    {
        printf("Usage: test dirname\n");
    }
    
    int main(int argc,char *argv[])
    {
        DIR * dp;
        struct dirent *filename;
        if (argc < 2)
        {
            print_usage();
            exit(1);
        }
    
        dp = opendir(argv[1]);
        if (!dp)
        {
            fprintf(stderr,"open directory error\n");
            return 0;
        }
        while (filename = readdir(dp))
        {
            printf("filename:%-10s\td_info:%ld\t d_reclen:%us\n",
            filename->d_name,filename->d_ino,filename->d_reclen);
        }
        closedir(dp);
        return 0;
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • VS2103没有“dirent.h”文件

    千次阅读 2019-06-29 16:43:39
    在VS2013中使用dirent.h文件时,找不到该文件。 错误描述: 无法打开包括文件"dirent.h":No such file or directory 2 原因 windows兼容dirent.h文中所述: “<dirent.h>是个unix系统下常见的接口,但windows...

    1 问题描述

    在这里插入图片描述
    在VS2013中使用dirent.h文件时,找不到该文件。
    错误描述:
    无法打开包括文件"dirent.h":No such file or directory

    2 原因

    windows兼容dirent.h文中所述:

    “<dirent.h>是个unix系统下常见的接口,但windows平台的MSVC编译器并没有提供这个接口,对于跨平台的项目开发就会带来一些麻烦,如果在MSVC下编译时可能因为windows平台缺少这个接口就要为windows平台另外写一些代码。”

    3 解决办法

    1. windows兼容dirent.h文中所述。
    2. 如果上述GitHub中的压缩包不能下载,则复制下面的代码,然后保存为“dirent.h”,放入VS的include文件夹下即可(具体步骤参见 4 解决步骤)
    /*
     * Dirent interface for Microsoft Visual Studio
     *
     * Copyright (C) 1998-2019 Toni Ronkko
     * This file is part of dirent.  Dirent may be freely distributed
     * under the MIT license.  For all details and documentation, see
     * https://github.com/tronkko/dirent
     */
    #ifndef DIRENT_H
    #define DIRENT_H
    
    /* Hide warnings about unreferenced local functions */
    #if defined(__clang__)
    #   pragma clang diagnostic ignored "-Wunused-function"
    #elif defined(_MSC_VER)
    #   pragma warning(disable:4505)
    #elif defined(__GNUC__)
    #   pragma GCC diagnostic ignored "-Wunused-function"
    #endif
    
    /*
     * Include windows.h without Windows Sockets 1.1 to prevent conflicts with
     * Windows Sockets 2.0.
     */
    #ifndef WIN32_LEAN_AND_MEAN
    #   define WIN32_LEAN_AND_MEAN
    #endif
    #include <windows.h>
    
    #include <stdio.h>
    #include <stdarg.h>
    #include <wchar.h>
    #include <string.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <errno.h>
    
    /* Indicates that d_type field is available in dirent structure */
    #define _DIRENT_HAVE_D_TYPE
    
    /* Indicates that d_namlen field is available in dirent structure */
    #define _DIRENT_HAVE_D_NAMLEN
    
    /* Entries missing from MSVC 6.0 */
    #if !defined(FILE_ATTRIBUTE_DEVICE)
    #   define FILE_ATTRIBUTE_DEVICE 0x40
    #endif
    
    /* File type and permission flags for stat(), general mask */
    #if !defined(S_IFMT)
    #   define S_IFMT _S_IFMT
    #endif
    
    /* Directory bit */
    #if !defined(S_IFDIR)
    #   define S_IFDIR _S_IFDIR
    #endif
    
    /* Character device bit */
    #if !defined(S_IFCHR)
    #   define S_IFCHR _S_IFCHR
    #endif
    
    /* Pipe bit */
    #if !defined(S_IFFIFO)
    #   define S_IFFIFO _S_IFFIFO
    #endif
    
    /* Regular file bit */
    #if !defined(S_IFREG)
    #   define S_IFREG _S_IFREG
    #endif
    
    /* Read permission */
    #if !defined(S_IREAD)
    #   define S_IREAD _S_IREAD
    #endif
    
    /* Write permission */
    #if !defined(S_IWRITE)
    #   define S_IWRITE _S_IWRITE
    #endif
    
    /* Execute permission */
    #if !defined(S_IEXEC)
    #   define S_IEXEC _S_IEXEC
    #endif
    
    /* Pipe */
    #if !defined(S_IFIFO)
    #   define S_IFIFO _S_IFIFO
    #endif
    
    /* Block device */
    #if !defined(S_IFBLK)
    #   define S_IFBLK 0
    #endif
    
    /* Link */
    #if !defined(S_IFLNK)
    #   define S_IFLNK 0
    #endif
    
    /* Socket */
    #if !defined(S_IFSOCK)
    #   define S_IFSOCK 0
    #endif
    
    /* Read user permission */
    #if !defined(S_IRUSR)
    #   define S_IRUSR S_IREAD
    #endif
    
    /* Write user permission */
    #if !defined(S_IWUSR)
    #   define S_IWUSR S_IWRITE
    #endif
    
    /* Execute user permission */
    #if !defined(S_IXUSR)
    #   define S_IXUSR 0
    #endif
    
    /* Read group permission */
    #if !defined(S_IRGRP)
    #   define S_IRGRP 0
    #endif
    
    /* Write group permission */
    #if !defined(S_IWGRP)
    #   define S_IWGRP 0
    #endif
    
    /* Execute group permission */
    #if !defined(S_IXGRP)
    #   define S_IXGRP 0
    #endif
    
    /* Read others permission */
    #if !defined(S_IROTH)
    #   define S_IROTH 0
    #endif
    
    /* Write others permission */
    #if !defined(S_IWOTH)
    #   define S_IWOTH 0
    #endif
    
    /* Execute others permission */
    #if !defined(S_IXOTH)
    #   define S_IXOTH 0
    #endif
    
    /* Maximum length of file name */
    #if !defined(PATH_MAX)
    #   define PATH_MAX MAX_PATH
    #endif
    #if !defined(FILENAME_MAX)
    #   define FILENAME_MAX MAX_PATH
    #endif
    #if !defined(NAME_MAX)
    #   define NAME_MAX FILENAME_MAX
    #endif
    
    /* File type flags for d_type */
    #define DT_UNKNOWN 0
    #define DT_REG S_IFREG
    #define DT_DIR S_IFDIR
    #define DT_FIFO S_IFIFO
    #define DT_SOCK S_IFSOCK
    #define DT_CHR S_IFCHR
    #define DT_BLK S_IFBLK
    #define DT_LNK S_IFLNK
    
    /* Macros for converting between st_mode and d_type */
    #define IFTODT(mode) ((mode) & S_IFMT)
    #define DTTOIF(type) (type)
    
    /*
     * File type macros.  Note that block devices, sockets and links cannot be
     * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are
     * only defined for compatibility.  These macros should always return false
     * on Windows.
     */
    #if !defined(S_ISFIFO)
    #   define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
    #endif
    #if !defined(S_ISDIR)
    #   define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
    #endif
    #if !defined(S_ISREG)
    #   define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
    #endif
    #if !defined(S_ISLNK)
    #   define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
    #endif
    #if !defined(S_ISSOCK)
    #   define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
    #endif
    #if !defined(S_ISCHR)
    #   define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR)
    #endif
    #if !defined(S_ISBLK)
    #   define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK)
    #endif
    
    /* Return the exact length of the file name without zero terminator */
    #define _D_EXACT_NAMLEN(p) ((p)->d_namlen)
    
    /* Return the maximum size of a file name */
    #define _D_ALLOC_NAMLEN(p) ((PATH_MAX)+1)
    
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    
    /* Wide-character version */
    struct _wdirent {
        /* Always zero */
        long d_ino;
    
        /* File position within stream */
        long d_off;
    
        /* Structure size */
        unsigned short d_reclen;
    
        /* Length of name without \0 */
        size_t d_namlen;
    
        /* File type */
        int d_type;
    
        /* File name */
        wchar_t d_name[PATH_MAX+1];
    };
    typedef struct _wdirent _wdirent;
    
    struct _WDIR {
        /* Current directory entry */
        struct _wdirent ent;
    
        /* Private file data */
        WIN32_FIND_DATAW data;
    
        /* True if data is valid */
        int cached;
    
        /* Win32 search handle */
        HANDLE handle;
    
        /* Initial directory name */
        wchar_t *patt;
    };
    typedef struct _WDIR _WDIR;
    
    /* Multi-byte character version */
    struct dirent {
        /* Always zero */
        long d_ino;
    
        /* File position within stream */
        long d_off;
    
        /* Structure size */
        unsigned short d_reclen;
    
        /* Length of name without \0 */
        size_t d_namlen;
    
        /* File type */
        int d_type;
    
        /* File name */
        char d_name[PATH_MAX+1];
    };
    typedef struct dirent dirent;
    
    struct DIR {
        struct dirent ent;
        struct _WDIR *wdirp;
    };
    typedef struct DIR DIR;
    
    
    /* Dirent functions */
    static DIR *opendir (const char *dirname);
    static _WDIR *_wopendir (const wchar_t *dirname);
    
    static struct dirent *readdir (DIR *dirp);
    static struct _wdirent *_wreaddir (_WDIR *dirp);
    
    static int readdir_r(
        DIR *dirp, struct dirent *entry, struct dirent **result);
    static int _wreaddir_r(
        _WDIR *dirp, struct _wdirent *entry, struct _wdirent **result);
    
    static int closedir (DIR *dirp);
    static int _wclosedir (_WDIR *dirp);
    
    static void rewinddir (DIR* dirp);
    static void _wrewinddir (_WDIR* dirp);
    
    static int scandir (const char *dirname, struct dirent ***namelist,
        int (*filter)(const struct dirent*),
        int (*compare)(const struct dirent**, const struct dirent**));
    
    static int alphasort (const struct dirent **a, const struct dirent **b);
    
    static int versionsort (const struct dirent **a, const struct dirent **b);
    
    
    /* For compatibility with Symbian */
    #define wdirent _wdirent
    #define WDIR _WDIR
    #define wopendir _wopendir
    #define wreaddir _wreaddir
    #define wclosedir _wclosedir
    #define wrewinddir _wrewinddir
    
    
    /* Internal utility functions */
    static WIN32_FIND_DATAW *dirent_first (_WDIR *dirp);
    static WIN32_FIND_DATAW *dirent_next (_WDIR *dirp);
    
    static int dirent_mbstowcs_s(
        size_t *pReturnValue,
        wchar_t *wcstr,
        size_t sizeInWords,
        const char *mbstr,
        size_t count);
    
    static int dirent_wcstombs_s(
        size_t *pReturnValue,
        char *mbstr,
        size_t sizeInBytes,
        const wchar_t *wcstr,
        size_t count);
    
    static void dirent_set_errno (int error);
    
    
    /*
     * Open directory stream DIRNAME for read and return a pointer to the
     * internal working area that is used to retrieve individual directory
     * entries.
     */
    static _WDIR*
    _wopendir(
        const wchar_t *dirname)
    {
        _WDIR *dirp;
        DWORD n;
        wchar_t *p;
    
        /* Must have directory name */
        if (dirname == NULL  ||  dirname[0] == '\0') {
            dirent_set_errno (ENOENT);
            return NULL;
        }
    
        /* Allocate new _WDIR structure */
        dirp = (_WDIR*) malloc (sizeof (struct _WDIR));
        if (!dirp) {
            return NULL;
        }
    
        /* Reset _WDIR structure */
        dirp->handle = INVALID_HANDLE_VALUE;
        dirp->patt = NULL;
        dirp->cached = 0;
    
        /*
         * Compute the length of full path plus zero terminator
         *
         * Note that on WinRT there's no way to convert relative paths
         * into absolute paths, so just assume it is an absolute path.
         */
    #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
        /* Desktop */
        n = GetFullPathNameW (dirname, 0, NULL, NULL);
    #else
        /* WinRT */
        n = wcslen (dirname);
    #endif
    
        /* Allocate room for absolute directory name and search pattern */
        dirp->patt = (wchar_t*) malloc (sizeof (wchar_t) * n + 16);
        if (dirp->patt == NULL) {
            goto exit_closedir;
        }
    
        /*
         * Convert relative directory name to an absolute one.  This
         * allows rewinddir() to function correctly even when current
         * working directory is changed between opendir() and rewinddir().
         *
         * Note that on WinRT there's no way to convert relative paths
         * into absolute paths, so just assume it is an absolute path.
         */
    #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
        /* Desktop */
        n = GetFullPathNameW (dirname, n, dirp->patt, NULL);
        if (n <= 0) {
            goto exit_closedir;
        }
    #else
        /* WinRT */
        wcsncpy_s (dirp->patt, n+1, dirname, n);
    #endif
    
        /* Append search pattern \* to the directory name */
        p = dirp->patt + n;
        switch (p[-1]) {
        case '\\':
        case '/':
        case ':':
            /* Directory ends in path separator, e.g. c:\temp\ */
            /*NOP*/;
            break;
    
        default:
            /* Directory name doesn't end in path separator */
            *p++ = '\\';
        }
        *p++ = '*';
        *p = '\0';
    
        /* Open directory stream and retrieve the first entry */
        if (!dirent_first (dirp)) {
            goto exit_closedir;
        }
    
        /* Success */
        return dirp;
    
        /* Failure */
    exit_closedir:
        _wclosedir (dirp);
        return NULL;
    }
    
    /*
     * Read next directory entry.
     *
     * Returns pointer to static directory entry which may be overwritten by
     * subsequent calls to _wreaddir().
     */
    static struct _wdirent*
    _wreaddir(
        _WDIR *dirp)
    {
        struct _wdirent *entry;
    
        /*
         * Read directory entry to buffer.  We can safely ignore the return value
         * as entry will be set to NULL in case of error.
         */
        (void) _wreaddir_r (dirp, &dirp->ent, &entry);
    
        /* Return pointer to statically allocated directory entry */
        return entry;
    }
    
    /*
     * Read next directory entry.
     *
     * Returns zero on success.  If end of directory stream is reached, then sets
     * result to NULL and returns zero.
     */
    static int
    _wreaddir_r(
        _WDIR *dirp,
        struct _wdirent *entry,
        struct _wdirent **result)
    {
        WIN32_FIND_DATAW *datap;
    
        /* Read next directory entry */
        datap = dirent_next (dirp);
        if (datap) {
            size_t n;
            DWORD attr;
    
            /*
             * Copy file name as wide-character string.  If the file name is too
             * long to fit in to the destination buffer, then truncate file name
             * to PATH_MAX characters and zero-terminate the buffer.
             */
            n = 0;
            while (n < PATH_MAX  &&  datap->cFileName[n] != 0) {
                entry->d_name[n] = datap->cFileName[n];
                n++;
            }
            entry->d_name[n] = 0;
    
            /* Length of file name excluding zero terminator */
            entry->d_namlen = n;
    
            /* File type */
            attr = datap->dwFileAttributes;
            if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
                entry->d_type = DT_CHR;
            } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
                entry->d_type = DT_DIR;
            } else {
                entry->d_type = DT_REG;
            }
    
            /* Reset dummy fields */
            entry->d_ino = 0;
            entry->d_off = 0;
            entry->d_reclen = sizeof (struct _wdirent);
    
            /* Set result address */
            *result = entry;
    
        } else {
    
            /* Return NULL to indicate end of directory */
            *result = NULL;
    
        }
    
        return /*OK*/0;
    }
    
    /*
     * Close directory stream opened by opendir() function.  This invalidates the
     * DIR structure as well as any directory entry read previously by
     * _wreaddir().
     */
    static int
    _wclosedir(
        _WDIR *dirp)
    {
        int ok;
        if (dirp) {
    
            /* Release search handle */
            if (dirp->handle != INVALID_HANDLE_VALUE) {
                FindClose (dirp->handle);
            }
    
            /* Release search pattern */
            free (dirp->patt);
    
            /* Release directory structure */
            free (dirp);
            ok = /*success*/0;
    
        } else {
    
            /* Invalid directory stream */
            dirent_set_errno (EBADF);
            ok = /*failure*/-1;
    
        }
        return ok;
    }
    
    /*
     * Rewind directory stream such that _wreaddir() returns the very first
     * file name again.
     */
    static void
    _wrewinddir(
        _WDIR* dirp)
    {
        if (dirp) {
            /* Release existing search handle */
            if (dirp->handle != INVALID_HANDLE_VALUE) {
                FindClose (dirp->handle);
            }
    
            /* Open new search handle */
            dirent_first (dirp);
        }
    }
    
    /* Get first directory entry (internal) */
    static WIN32_FIND_DATAW*
    dirent_first(
        _WDIR *dirp)
    {
        WIN32_FIND_DATAW *datap;
        DWORD error;
    
        /* Open directory and retrieve the first entry */
        dirp->handle = FindFirstFileExW(
            dirp->patt, FindExInfoStandard, &dirp->data,
            FindExSearchNameMatch, NULL, 0);
        if (dirp->handle != INVALID_HANDLE_VALUE) {
    
            /* a directory entry is now waiting in memory */
            datap = &dirp->data;
            dirp->cached = 1;
    
        } else {
    
            /* Failed to open directory: no directory entry in memory */
            dirp->cached = 0;
            datap = NULL;
    
            /* Set error code */
            error = GetLastError ();
            switch (error) {
            case ERROR_ACCESS_DENIED:
                /* No read access to directory */
                dirent_set_errno (EACCES);
                break;
    
            case ERROR_DIRECTORY:
                /* Directory name is invalid */
                dirent_set_errno (ENOTDIR);
                break;
    
            case ERROR_PATH_NOT_FOUND:
            default:
                /* Cannot find the file */
                dirent_set_errno (ENOENT);
            }
    
        }
        return datap;
    }
    
    /*
     * Get next directory entry (internal).
     *
     * Returns
     */
    static WIN32_FIND_DATAW*
    dirent_next(
        _WDIR *dirp)
    {
        WIN32_FIND_DATAW *p;
    
        /* Get next directory entry */
        if (dirp->cached != 0) {
    
            /* A valid directory entry already in memory */
            p = &dirp->data;
            dirp->cached = 0;
    
        } else if (dirp->handle != INVALID_HANDLE_VALUE) {
    
            /* Get the next directory entry from stream */
            if (FindNextFileW (dirp->handle, &dirp->data) != FALSE) {
                /* Got a file */
                p = &dirp->data;
            } else {
                /* The very last entry has been processed or an error occurred */
                FindClose (dirp->handle);
                dirp->handle = INVALID_HANDLE_VALUE;
                p = NULL;
            }
    
        } else {
    
            /* End of directory stream reached */
            p = NULL;
    
        }
    
        return p;
    }
    
    /*
     * Open directory stream using plain old C-string.
     */
    static DIR*
    opendir(
        const char *dirname)
    {
        struct DIR *dirp;
    
        /* Must have directory name */
        if (dirname == NULL  ||  dirname[0] == '\0') {
            dirent_set_errno (ENOENT);
            return NULL;
        }
    
        /* Allocate memory for DIR structure */
        dirp = (DIR*) malloc (sizeof (struct DIR));
        if (!dirp) {
            return NULL;
        }
        {
            int error;
            wchar_t wname[PATH_MAX + 1];
            size_t n;
    
            /* Convert directory name to wide-character string */
            error = dirent_mbstowcs_s(
                &n, wname, PATH_MAX + 1, dirname, PATH_MAX + 1);
            if (error) {
                /*
                 * Cannot convert file name to wide-character string.  This
                 * occurs if the string contains invalid multi-byte sequences or
                 * the output buffer is too small to contain the resulting
                 * string.
                 */
                goto exit_free;
            }
    
    
            /* Open directory stream using wide-character name */
            dirp->wdirp = _wopendir (wname);
            if (!dirp->wdirp) {
                goto exit_free;
            }
    
        }
    
        /* Success */
        return dirp;
    
        /* Failure */
    exit_free:
        free (dirp);
        return NULL;
    }
    
    /*
     * Read next directory entry.
     */
    static struct dirent*
    readdir(
        DIR *dirp)
    {
        struct dirent *entry;
    
        /*
         * Read directory entry to buffer.  We can safely ignore the return value
         * as entry will be set to NULL in case of error.
         */
        (void) readdir_r (dirp, &dirp->ent, &entry);
    
        /* Return pointer to statically allocated directory entry */
        return entry;
    }
    
    /*
     * Read next directory entry into called-allocated buffer.
     *
     * Returns zero on success.  If the end of directory stream is reached, then
     * sets result to NULL and returns zero.
     */
    static int
    readdir_r(
        DIR *dirp,
        struct dirent *entry,
        struct dirent **result)
    {
        WIN32_FIND_DATAW *datap;
    
        /* Read next directory entry */
        datap = dirent_next (dirp->wdirp);
        if (datap) {
            size_t n;
            int error;
    
            /* Attempt to convert file name to multi-byte string */
            error = dirent_wcstombs_s(
                &n, entry->d_name, PATH_MAX + 1, datap->cFileName, PATH_MAX + 1);
    
            /*
             * If the file name cannot be represented by a multi-byte string,
             * then attempt to use old 8+3 file name.  This allows traditional
             * Unix-code to access some file names despite of unicode
             * characters, although file names may seem unfamiliar to the user.
             *
             * Be ware that the code below cannot come up with a short file
             * name unless the file system provides one.  At least
             * VirtualBox shared folders fail to do this.
             */
            if (error  &&  datap->cAlternateFileName[0] != '\0') {
                error = dirent_wcstombs_s(
                    &n, entry->d_name, PATH_MAX + 1,
                    datap->cAlternateFileName, PATH_MAX + 1);
            }
    
            if (!error) {
                DWORD attr;
    
                /* Length of file name excluding zero terminator */
                entry->d_namlen = n - 1;
    
                /* File attributes */
                attr = datap->dwFileAttributes;
                if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
                    entry->d_type = DT_CHR;
                } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
                    entry->d_type = DT_DIR;
                } else {
                    entry->d_type = DT_REG;
                }
    
                /* Reset dummy fields */
                entry->d_ino = 0;
                entry->d_off = 0;
                entry->d_reclen = sizeof (struct dirent);
    
            } else {
    
                /*
                 * Cannot convert file name to multi-byte string so construct
                 * an erroneous directory entry and return that.  Note that
                 * we cannot return NULL as that would stop the processing
                 * of directory entries completely.
                 */
                entry->d_name[0] = '?';
                entry->d_name[1] = '\0';
                entry->d_namlen = 1;
                entry->d_type = DT_UNKNOWN;
                entry->d_ino = 0;
                entry->d_off = -1;
                entry->d_reclen = 0;
    
            }
    
            /* Return pointer to directory entry */
            *result = entry;
    
        } else {
    
            /* No more directory entries */
            *result = NULL;
    
        }
    
        return /*OK*/0;
    }
    
    /*
     * Close directory stream.
     */
    static int
    closedir(
        DIR *dirp)
    {
        int ok;
        if (dirp) {
    
            /* Close wide-character directory stream */
            ok = _wclosedir (dirp->wdirp);
            dirp->wdirp = NULL;
    
            /* Release multi-byte character version */
            free (dirp);
    
        } else {
    
            /* Invalid directory stream */
            dirent_set_errno (EBADF);
            ok = /*failure*/-1;
    
        }
        return ok;
    }
    
    /*
     * Rewind directory stream to beginning.
     */
    static void
    rewinddir(
        DIR* dirp)
    {
        /* Rewind wide-character string directory stream */
        _wrewinddir (dirp->wdirp);
    }
    
    /*
     * Scan directory for entries.
     */
    static int
    scandir(
        const char *dirname,
        struct dirent ***namelist,
        int (*filter)(const struct dirent*),
        int (*compare)(const struct dirent**, const struct dirent**))
    {
        struct dirent **files = NULL;
        size_t size = 0;
        size_t allocated = 0;
        const size_t init_size = 1;
        DIR *dir = NULL;
        struct dirent *entry;
        struct dirent *tmp = NULL;
        size_t i;
        int result = 0;
    
        /* Open directory stream */
        dir = opendir (dirname);
        if (dir) {
    
            /* Read directory entries to memory */
            while (1) {
    
                /* Enlarge pointer table to make room for another pointer */
                if (size >= allocated) {
                    void *p;
                    size_t num_entries;
    
                    /* Compute number of entries in the enlarged pointer table */
                    if (size < init_size) {
                        /* Allocate initial pointer table */
                        num_entries = init_size;
                    } else {
                        /* Double the size */
                        num_entries = size * 2;
                    }
    
                    /* Allocate first pointer table or enlarge existing table */
                    p = realloc (files, sizeof (void*) * num_entries);
                    if (p != NULL) {
                        /* Got the memory */
                        files = (dirent**) p;
                        allocated = num_entries;
                    } else {
                        /* Out of memory */
                        result = -1;
                        break;
                    }
    
                }
    
                /* Allocate room for temporary directory entry */
                if (tmp == NULL) {
                    tmp = (struct dirent*) malloc (sizeof (struct dirent));
                    if (tmp == NULL) {
                        /* Cannot allocate temporary directory entry */
                        result = -1;
                        break;
                    }
                }
    
                /* Read directory entry to temporary area */
                if (readdir_r (dir, tmp, &entry) == /*OK*/0) {
    
                    /* Did we get an entry? */
                    if (entry != NULL) {
                        int pass;
    
                        /* Determine whether to include the entry in result */
                        if (filter) {
                            /* Let the filter function decide */
                            pass = filter (tmp);
                        } else {
                            /* No filter function, include everything */
                            pass = 1;
                        }
    
                        if (pass) {
                            /* Store the temporary entry to pointer table */
                            files[size++] = tmp;
                            tmp = NULL;
    
                            /* Keep up with the number of files */
                            result++;
                        }
    
                    } else {
    
                        /*
                         * End of directory stream reached => sort entries and
                         * exit.
                         */
                        qsort (files, size, sizeof (void*),
                            (int (*) (const void*, const void*)) compare);
                        break;
    
                    }
    
                } else {
                    /* Error reading directory entry */
                    result = /*Error*/ -1;
                    break;
                }
    
            }
    
        } else {
            /* Cannot open directory */
            result = /*Error*/ -1;
        }
    
        /* Release temporary directory entry */
        free (tmp);
    
        /* Release allocated memory on error */
        if (result < 0) {
            for (i = 0; i < size; i++) {
                free (files[i]);
            }
            free (files);
            files = NULL;
        }
    
        /* Close directory stream */
        if (dir) {
            closedir (dir);
        }
    
        /* Pass pointer table to caller */
        if (namelist) {
            *namelist = files;
        }
        return result;
    }
    
    /* Alphabetical sorting */
    static int
    alphasort(
        const struct dirent **a, const struct dirent **b)
    {
        return strcoll ((*a)->d_name, (*b)->d_name);
    }
    
    /* Sort versions */
    static int
    versionsort(
        const struct dirent **a, const struct dirent **b)
    {
        /* FIXME: implement strverscmp and use that */
        return alphasort (a, b);
    }
    
    /* Convert multi-byte string to wide character string */
    static int
    dirent_mbstowcs_s(
        size_t *pReturnValue,
        wchar_t *wcstr,
        size_t sizeInWords,
        const char *mbstr,
        size_t count)
    {
        int error;
    
    #if defined(_MSC_VER)  &&  _MSC_VER >= 1400
    
        /* Microsoft Visual Studio 2005 or later */
        error = mbstowcs_s (pReturnValue, wcstr, sizeInWords, mbstr, count);
    
    #else
    
        /* Older Visual Studio or non-Microsoft compiler */
        size_t n;
    
        /* Convert to wide-character string (or count characters) */
        n = mbstowcs (wcstr, mbstr, sizeInWords);
        if (!wcstr  ||  n < count) {
    
            /* Zero-terminate output buffer */
            if (wcstr  &&  sizeInWords) {
                if (n >= sizeInWords) {
                    n = sizeInWords - 1;
                }
                wcstr[n] = 0;
            }
    
            /* Length of resulting multi-byte string WITH zero terminator */
            if (pReturnValue) {
                *pReturnValue = n + 1;
            }
    
            /* Success */
            error = 0;
    
        } else {
    
            /* Could not convert string */
            error = 1;
    
        }
    
    #endif
        return error;
    }
    
    /* Convert wide-character string to multi-byte string */
    static int
    dirent_wcstombs_s(
        size_t *pReturnValue,
        char *mbstr,
        size_t sizeInBytes, /* max size of mbstr */
        const wchar_t *wcstr,
        size_t count)
    {
        int error;
    
    #if defined(_MSC_VER)  &&  _MSC_VER >= 1400
    
        /* Microsoft Visual Studio 2005 or later */
        error = wcstombs_s (pReturnValue, mbstr, sizeInBytes, wcstr, count);
    
    #else
    
        /* Older Visual Studio or non-Microsoft compiler */
        size_t n;
    
        /* Convert to multi-byte string (or count the number of bytes needed) */
        n = wcstombs (mbstr, wcstr, sizeInBytes);
        if (!mbstr  ||  n < count) {
    
            /* Zero-terminate output buffer */
            if (mbstr  &&  sizeInBytes) {
                if (n >= sizeInBytes) {
                    n = sizeInBytes - 1;
                }
                mbstr[n] = '\0';
            }
    
            /* Length of resulting multi-bytes string WITH zero-terminator */
            if (pReturnValue) {
                *pReturnValue = n + 1;
            }
    
            /* Success */
            error = 0;
    
        } else {
    
            /* Cannot convert string */
            error = 1;
    
        }
    
    #endif
        return error;
    }
    
    /* Set errno variable */
    static void
    dirent_set_errno(
        int error)
    {
    #if defined(_MSC_VER)  &&  _MSC_VER >= 1400
    
        /* Microsoft Visual Studio 2005 and later */
        _set_errno (error);
    
    #else
    
        /* Non-Microsoft compiler or older Microsoft compiler */
        errno = error;
    
    #endif
    }
    
    
    #ifdef __cplusplus
    }
    #endif
    #endif /*DIRENT_H*/
    
    

    4 具体步骤

    1. 上述代码复制到文件中,保存为dirent.h
    2. dirent.h文件放入include文件夹内,如:
      D:\Program Files\Microsoft Visual Studio\VC\include

    5 参考链接

    1. windows兼容dirent.h
    2. Gihub下载地址
    展开全文
  • 将以下代码报错成dirent.h头文件 将dirent.h文件放入Microsoft Visual Studio的include文件夹内,如: C:\Program Files\Microsoft Visual Studio\VC\include /* * Dirent interface for Microsoft Visual Studio...

    解决办法:

    1. 将以下代码报错成dirent.h头文件
    2. 将dirent.h文件放入Microsoft Visual Studio的include文件夹内,如:
    C:\Program Files\Microsoft Visual Studio\VC\include
    
    /*
     * Dirent interface for Microsoft Visual Studio
     *
     * Copyright (C) 1998-2019 Toni Ronkko
     * This file is part of dirent.  Dirent may be freely distributed
     * under the MIT license.  For all details and documentation, see
     * https://github.com/tronkko/dirent
     */
    #ifndef DIRENT_H
    #define DIRENT_H
    
    /* Hide warnings about unreferenced local functions */
    #if defined(__clang__)
    #   pragma clang diagnostic ignored "-Wunused-function"
    #elif defined(_MSC_VER)
    #   pragma warning(disable:4505)
    #elif defined(__GNUC__)
    #   pragma GCC diagnostic ignored "-Wunused-function"
    #endif
    
    /*
     * Include windows.h without Windows Sockets 1.1 to prevent conflicts with
     * Windows Sockets 2.0.
     */
    #ifndef WIN32_LEAN_AND_MEAN
    #   define WIN32_LEAN_AND_MEAN
    #endif
    #include <windows.h>
    
    #include <stdio.h>
    #include <stdarg.h>
    #include <wchar.h>
    #include <string.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <errno.h>
    
    /* Indicates that d_type field is available in dirent structure */
    #define _DIRENT_HAVE_D_TYPE
    
    /* Indicates that d_namlen field is available in dirent structure */
    #define _DIRENT_HAVE_D_NAMLEN
    
    /* Entries missing from MSVC 6.0 */
    #if !defined(FILE_ATTRIBUTE_DEVICE)
    #   define FILE_ATTRIBUTE_DEVICE 0x40
    #endif
    
    /* File type and permission flags for stat(), general mask */
    #if !defined(S_IFMT)
    #   define S_IFMT _S_IFMT
    #endif
    
    /* Directory bit */
    #if !defined(S_IFDIR)
    #   define S_IFDIR _S_IFDIR
    #endif
    
    /* Character device bit */
    #if !defined(S_IFCHR)
    #   define S_IFCHR _S_IFCHR
    #endif
    
    /* Pipe bit */
    #if !defined(S_IFFIFO)
    #   define S_IFFIFO _S_IFFIFO
    #endif
    
    /* Regular file bit */
    #if !defined(S_IFREG)
    #   define S_IFREG _S_IFREG
    #endif
    
    /* Read permission */
    #if !defined(S_IREAD)
    #   define S_IREAD _S_IREAD
    #endif
    
    /* Write permission */
    #if !defined(S_IWRITE)
    #   define S_IWRITE _S_IWRITE
    #endif
    
    /* Execute permission */
    #if !defined(S_IEXEC)
    #   define S_IEXEC _S_IEXEC
    #endif
    
    /* Pipe */
    #if !defined(S_IFIFO)
    #   define S_IFIFO _S_IFIFO
    #endif
    
    /* Block device */
    #if !defined(S_IFBLK)
    #   define S_IFBLK 0
    #endif
    
    /* Link */
    #if !defined(S_IFLNK)
    #   define S_IFLNK 0
    #endif
    
    /* Socket */
    #if !defined(S_IFSOCK)
    #   define S_IFSOCK 0
    #endif
    
    /* Read user permission */
    #if !defined(S_IRUSR)
    #   define S_IRUSR S_IREAD
    #endif
    
    /* Write user permission */
    #if !defined(S_IWUSR)
    #   define S_IWUSR S_IWRITE
    #endif
    
    /* Execute user permission */
    #if !defined(S_IXUSR)
    #   define S_IXUSR 0
    #endif
    
    /* Read group permission */
    #if !defined(S_IRGRP)
    #   define S_IRGRP 0
    #endif
    
    /* Write group permission */
    #if !defined(S_IWGRP)
    #   define S_IWGRP 0
    #endif
    
    /* Execute group permission */
    #if !defined(S_IXGRP)
    #   define S_IXGRP 0
    #endif
    
    /* Read others permission */
    #if !defined(S_IROTH)
    #   define S_IROTH 0
    #endif
    
    /* Write others permission */
    #if !defined(S_IWOTH)
    #   define S_IWOTH 0
    #endif
    
    /* Execute others permission */
    #if !defined(S_IXOTH)
    #   define S_IXOTH 0
    #endif
    
    /* Maximum length of file name */
    #if !defined(PATH_MAX)
    #   define PATH_MAX MAX_PATH
    #endif
    #if !defined(FILENAME_MAX)
    #   define FILENAME_MAX MAX_PATH
    #endif
    #if !defined(NAME_MAX)
    #   define NAME_MAX FILENAME_MAX
    #endif
    
    /* File type flags for d_type */
    #define DT_UNKNOWN 0
    #define DT_REG S_IFREG
    #define DT_DIR S_IFDIR
    #define DT_FIFO S_IFIFO
    #define DT_SOCK S_IFSOCK
    #define DT_CHR S_IFCHR
    #define DT_BLK S_IFBLK
    #define DT_LNK S_IFLNK
    
    /* Macros for converting between st_mode and d_type */
    #define IFTODT(mode) ((mode) & S_IFMT)
    #define DTTOIF(type) (type)
    
    /*
     * File type macros.  Note that block devices, sockets and links cannot be
     * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are
     * only defined for compatibility.  These macros should always return false
     * on Windows.
     */
    #if !defined(S_ISFIFO)
    #   define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
    #endif
    #if !defined(S_ISDIR)
    #   define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
    #endif
    #if !defined(S_ISREG)
    #   define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
    #endif
    #if !defined(S_ISLNK)
    #   define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
    #endif
    #if !defined(S_ISSOCK)
    #   define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
    #endif
    #if !defined(S_ISCHR)
    #   define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR)
    #endif
    #if !defined(S_ISBLK)
    #   define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK)
    #endif
    
    /* Return the exact length of the file name without zero terminator */
    #define _D_EXACT_NAMLEN(p) ((p)->d_namlen)
    
    /* Return the maximum size of a file name */
    #define _D_ALLOC_NAMLEN(p) ((PATH_MAX)+1)
    
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    
    /* Wide-character version */
    struct _wdirent {
        /* Always zero */
        long d_ino;
    
        /* File position within stream */
        long d_off;
    
        /* Structure size */
        unsigned short d_reclen;
    
        /* Length of name without \0 */
        size_t d_namlen;
    
        /* File type */
        int d_type;
    
        /* File name */
        wchar_t d_name[PATH_MAX+1];
    };
    typedef struct _wdirent _wdirent;
    
    struct _WDIR {
        /* Current directory entry */
        struct _wdirent ent;
    
        /* Private file data */
        WIN32_FIND_DATAW data;
    
        /* True if data is valid */
        int cached;
    
        /* Win32 search handle */
        HANDLE handle;
    
        /* Initial directory name */
        wchar_t *patt;
    };
    typedef struct _WDIR _WDIR;
    
    /* Multi-byte character version */
    struct dirent {
        /* Always zero */
        long d_ino;
    
        /* File position within stream */
        long d_off;
    
        /* Structure size */
        unsigned short d_reclen;
    
        /* Length of name without \0 */
        size_t d_namlen;
    
        /* File type */
        int d_type;
    
        /* File name */
        char d_name[PATH_MAX+1];
    };
    typedef struct dirent dirent;
    
    struct DIR {
        struct dirent ent;
        struct _WDIR *wdirp;
    };
    typedef struct DIR DIR;
    
    
    /* Dirent functions */
    static DIR *opendir (const char *dirname);
    static _WDIR *_wopendir (const wchar_t *dirname);
    
    static struct dirent *readdir (DIR *dirp);
    static struct _wdirent *_wreaddir (_WDIR *dirp);
    
    static int readdir_r(
        DIR *dirp, struct dirent *entry, struct dirent **result);
    static int _wreaddir_r(
        _WDIR *dirp, struct _wdirent *entry, struct _wdirent **result);
    
    static int closedir (DIR *dirp);
    static int _wclosedir (_WDIR *dirp);
    
    static void rewinddir (DIR* dirp);
    static void _wrewinddir (_WDIR* dirp);
    
    static int scandir (const char *dirname, struct dirent ***namelist,
        int (*filter)(const struct dirent*),
        int (*compare)(const struct dirent**, const struct dirent**));
    
    static int alphasort (const struct dirent **a, const struct dirent **b);
    
    static int versionsort (const struct dirent **a, const struct dirent **b);
    
    
    /* For compatibility with Symbian */
    #define wdirent _wdirent
    #define WDIR _WDIR
    #define wopendir _wopendir
    #define wreaddir _wreaddir
    #define wclosedir _wclosedir
    #define wrewinddir _wrewinddir
    
    
    /* Internal utility functions */
    static WIN32_FIND_DATAW *dirent_first (_WDIR *dirp);
    static WIN32_FIND_DATAW *dirent_next (_WDIR *dirp);
    
    static int dirent_mbstowcs_s(
        size_t *pReturnValue,
        wchar_t *wcstr,
        size_t sizeInWords,
        const char *mbstr,
        size_t count);
    
    static int dirent_wcstombs_s(
        size_t *pReturnValue,
        char *mbstr,
        size_t sizeInBytes,
        const wchar_t *wcstr,
        size_t count);
    
    static void dirent_set_errno (int error);
    
    
    /*
     * Open directory stream DIRNAME for read and return a pointer to the
     * internal working area that is used to retrieve individual directory
     * entries.
     */
    static _WDIR*
    _wopendir(
        const wchar_t *dirname)
    {
        _WDIR *dirp;
        DWORD n;
        wchar_t *p;
    
        /* Must have directory name */
        if (dirname == NULL  ||  dirname[0] == '\0') {
            dirent_set_errno (ENOENT);
            return NULL;
        }
    
        /* Allocate new _WDIR structure */
        dirp = (_WDIR*) malloc (sizeof (struct _WDIR));
        if (!dirp) {
            return NULL;
        }
    
        /* Reset _WDIR structure */
        dirp->handle = INVALID_HANDLE_VALUE;
        dirp->patt = NULL;
        dirp->cached = 0;
    
        /*
         * Compute the length of full path plus zero terminator
         *
         * Note that on WinRT there's no way to convert relative paths
         * into absolute paths, so just assume it is an absolute path.
         */
    #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
        /* Desktop */
        n = GetFullPathNameW (dirname, 0, NULL, NULL);
    #else
        /* WinRT */
        n = wcslen (dirname);
    #endif
    
        /* Allocate room for absolute directory name and search pattern */
        dirp->patt = (wchar_t*) malloc (sizeof (wchar_t) * n + 16);
        if (dirp->patt == NULL) {
            goto exit_closedir;
        }
    
        /*
         * Convert relative directory name to an absolute one.  This
         * allows rewinddir() to function correctly even when current
         * working directory is changed between opendir() and rewinddir().
         *
         * Note that on WinRT there's no way to convert relative paths
         * into absolute paths, so just assume it is an absolute path.
         */
    #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
        /* Desktop */
        n = GetFullPathNameW (dirname, n, dirp->patt, NULL);
        if (n <= 0) {
            goto exit_closedir;
        }
    #else
        /* WinRT */
        wcsncpy_s (dirp->patt, n+1, dirname, n);
    #endif
    
        /* Append search pattern \* to the directory name */
        p = dirp->patt + n;
        switch (p[-1]) {
        case '\\':
        case '/':
        case ':':
            /* Directory ends in path separator, e.g. c:\temp\ */
            /*NOP*/;
            break;
    
        default:
            /* Directory name doesn't end in path separator */
            *p++ = '\\';
        }
        *p++ = '*';
        *p = '\0';
    
        /* Open directory stream and retrieve the first entry */
        if (!dirent_first (dirp)) {
            goto exit_closedir;
        }
    
        /* Success */
        return dirp;
    
        /* Failure */
    exit_closedir:
        _wclosedir (dirp);
        return NULL;
    }
    
    /*
     * Read next directory entry.
     *
     * Returns pointer to static directory entry which may be overwritten by
     * subsequent calls to _wreaddir().
     */
    static struct _wdirent*
    _wreaddir(
        _WDIR *dirp)
    {
        struct _wdirent *entry;
    
        /*
         * Read directory entry to buffer.  We can safely ignore the return value
         * as entry will be set to NULL in case of error.
         */
        (void) _wreaddir_r (dirp, &dirp->ent, &entry);
    
        /* Return pointer to statically allocated directory entry */
        return entry;
    }
    
    /*
     * Read next directory entry.
     *
     * Returns zero on success.  If end of directory stream is reached, then sets
     * result to NULL and returns zero.
     */
    static int
    _wreaddir_r(
        _WDIR *dirp,
        struct _wdirent *entry,
        struct _wdirent **result)
    {
        WIN32_FIND_DATAW *datap;
    
        /* Read next directory entry */
        datap = dirent_next (dirp);
        if (datap) {
            size_t n;
            DWORD attr;
    
            /*
             * Copy file name as wide-character string.  If the file name is too
             * long to fit in to the destination buffer, then truncate file name
             * to PATH_MAX characters and zero-terminate the buffer.
             */
            n = 0;
            while (n < PATH_MAX  &&  datap->cFileName[n] != 0) {
                entry->d_name[n] = datap->cFileName[n];
                n++;
            }
            entry->d_name[n] = 0;
    
            /* Length of file name excluding zero terminator */
            entry->d_namlen = n;
    
            /* File type */
            attr = datap->dwFileAttributes;
            if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
                entry->d_type = DT_CHR;
            } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
                entry->d_type = DT_DIR;
            } else {
                entry->d_type = DT_REG;
            }
    
            /* Reset dummy fields */
            entry->d_ino = 0;
            entry->d_off = 0;
            entry->d_reclen = sizeof (struct _wdirent);
    
            /* Set result address */
            *result = entry;
    
        } else {
    
            /* Return NULL to indicate end of directory */
            *result = NULL;
    
        }
    
        return /*OK*/0;
    }
    
    /*
     * Close directory stream opened by opendir() function.  This invalidates the
     * DIR structure as well as any directory entry read previously by
     * _wreaddir().
     */
    static int
    _wclosedir(
        _WDIR *dirp)
    {
        int ok;
        if (dirp) {
    
            /* Release search handle */
            if (dirp->handle != INVALID_HANDLE_VALUE) {
                FindClose (dirp->handle);
            }
    
            /* Release search pattern */
            free (dirp->patt);
    
            /* Release directory structure */
            free (dirp);
            ok = /*success*/0;
    
        } else {
    
            /* Invalid directory stream */
            dirent_set_errno (EBADF);
            ok = /*failure*/-1;
    
        }
        return ok;
    }
    
    /*
     * Rewind directory stream such that _wreaddir() returns the very first
     * file name again.
     */
    static void
    _wrewinddir(
        _WDIR* dirp)
    {
        if (dirp) {
            /* Release existing search handle */
            if (dirp->handle != INVALID_HANDLE_VALUE) {
                FindClose (dirp->handle);
            }
    
            /* Open new search handle */
            dirent_first (dirp);
        }
    }
    
    /* Get first directory entry (internal) */
    static WIN32_FIND_DATAW*
    dirent_first(
        _WDIR *dirp)
    {
        WIN32_FIND_DATAW *datap;
        DWORD error;
    
        /* Open directory and retrieve the first entry */
        dirp->handle = FindFirstFileExW(
            dirp->patt, FindExInfoStandard, &dirp->data,
            FindExSearchNameMatch, NULL, 0);
        if (dirp->handle != INVALID_HANDLE_VALUE) {
    
            /* a directory entry is now waiting in memory */
            datap = &dirp->data;
            dirp->cached = 1;
    
        } else {
    
            /* Failed to open directory: no directory entry in memory */
            dirp->cached = 0;
            datap = NULL;
    
            /* Set error code */
            error = GetLastError ();
            switch (error) {
            case ERROR_ACCESS_DENIED:
                /* No read access to directory */
                dirent_set_errno (EACCES);
                break;
    
            case ERROR_DIRECTORY:
                /* Directory name is invalid */
                dirent_set_errno (ENOTDIR);
                break;
    
            case ERROR_PATH_NOT_FOUND:
            default:
                /* Cannot find the file */
                dirent_set_errno (ENOENT);
            }
    
        }
        return datap;
    }
    
    /*
     * Get next directory entry (internal).
     *
     * Returns
     */
    static WIN32_FIND_DATAW*
    dirent_next(
        _WDIR *dirp)
    {
        WIN32_FIND_DATAW *p;
    
        /* Get next directory entry */
        if (dirp->cached != 0) {
    
            /* A valid directory entry already in memory */
            p = &dirp->data;
            dirp->cached = 0;
    
        } else if (dirp->handle != INVALID_HANDLE_VALUE) {
    
            /* Get the next directory entry from stream */
            if (FindNextFileW (dirp->handle, &dirp->data) != FALSE) {
                /* Got a file */
                p = &dirp->data;
            } else {
                /* The very last entry has been processed or an error occurred */
                FindClose (dirp->handle);
                dirp->handle = INVALID_HANDLE_VALUE;
                p = NULL;
            }
    
        } else {
    
            /* End of directory stream reached */
            p = NULL;
    
        }
    
        return p;
    }
    
    /*
     * Open directory stream using plain old C-string.
     */
    static DIR*
    opendir(
        const char *dirname)
    {
        struct DIR *dirp;
    
        /* Must have directory name */
        if (dirname == NULL  ||  dirname[0] == '\0') {
            dirent_set_errno (ENOENT);
            return NULL;
        }
    
        /* Allocate memory for DIR structure */
        dirp = (DIR*) malloc (sizeof (struct DIR));
        if (!dirp) {
            return NULL;
        }
        {
            int error;
            wchar_t wname[PATH_MAX + 1];
            size_t n;
    
            /* Convert directory name to wide-character string */
            error = dirent_mbstowcs_s(
                &n, wname, PATH_MAX + 1, dirname, PATH_MAX + 1);
            if (error) {
                /*
                 * Cannot convert file name to wide-character string.  This
                 * occurs if the string contains invalid multi-byte sequences or
                 * the output buffer is too small to contain the resulting
                 * string.
                 */
                goto exit_free;
            }
    
    
            /* Open directory stream using wide-character name */
            dirp->wdirp = _wopendir (wname);
            if (!dirp->wdirp) {
                goto exit_free;
            }
    
        }
    
        /* Success */
        return dirp;
    
        /* Failure */
    exit_free:
        free (dirp);
        return NULL;
    }
    
    /*
     * Read next directory entry.
     */
    static struct dirent*
    readdir(
        DIR *dirp)
    {
        struct dirent *entry;
    
        /*
         * Read directory entry to buffer.  We can safely ignore the return value
         * as entry will be set to NULL in case of error.
         */
        (void) readdir_r (dirp, &dirp->ent, &entry);
    
        /* Return pointer to statically allocated directory entry */
        return entry;
    }
    
    /*
     * Read next directory entry into called-allocated buffer.
     *
     * Returns zero on success.  If the end of directory stream is reached, then
     * sets result to NULL and returns zero.
     */
    static int
    readdir_r(
        DIR *dirp,
        struct dirent *entry,
        struct dirent **result)
    {
        WIN32_FIND_DATAW *datap;
    
        /* Read next directory entry */
        datap = dirent_next (dirp->wdirp);
        if (datap) {
            size_t n;
            int error;
    
            /* Attempt to convert file name to multi-byte string */
            error = dirent_wcstombs_s(
                &n, entry->d_name, PATH_MAX + 1, datap->cFileName, PATH_MAX + 1);
    
            /*
             * If the file name cannot be represented by a multi-byte string,
             * then attempt to use old 8+3 file name.  This allows traditional
             * Unix-code to access some file names despite of unicode
             * characters, although file names may seem unfamiliar to the user.
             *
             * Be ware that the code below cannot come up with a short file
             * name unless the file system provides one.  At least
             * VirtualBox shared folders fail to do this.
             */
            if (error  &&  datap->cAlternateFileName[0] != '\0') {
                error = dirent_wcstombs_s(
                    &n, entry->d_name, PATH_MAX + 1,
                    datap->cAlternateFileName, PATH_MAX + 1);
            }
    
            if (!error) {
                DWORD attr;
    
                /* Length of file name excluding zero terminator */
                entry->d_namlen = n - 1;
    
                /* File attributes */
                attr = datap->dwFileAttributes;
                if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
                    entry->d_type = DT_CHR;
                } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
                    entry->d_type = DT_DIR;
                } else {
                    entry->d_type = DT_REG;
                }
    
                /* Reset dummy fields */
                entry->d_ino = 0;
                entry->d_off = 0;
                entry->d_reclen = sizeof (struct dirent);
    
            } else {
    
                /*
                 * Cannot convert file name to multi-byte string so construct
                 * an erroneous directory entry and return that.  Note that
                 * we cannot return NULL as that would stop the processing
                 * of directory entries completely.
                 */
                entry->d_name[0] = '?';
                entry->d_name[1] = '\0';
                entry->d_namlen = 1;
                entry->d_type = DT_UNKNOWN;
                entry->d_ino = 0;
                entry->d_off = -1;
                entry->d_reclen = 0;
    
            }
    
            /* Return pointer to directory entry */
            *result = entry;
    
        } else {
    
            /* No more directory entries */
            *result = NULL;
    
        }
    
        return /*OK*/0;
    }
    
    /*
     * Close directory stream.
     */
    static int
    closedir(
        DIR *dirp)
    {
        int ok;
        if (dirp) {
    
            /* Close wide-character directory stream */
            ok = _wclosedir (dirp->wdirp);
            dirp->wdirp = NULL;
    
            /* Release multi-byte character version */
            free (dirp);
    
        } else {
    
            /* Invalid directory stream */
            dirent_set_errno (EBADF);
            ok = /*failure*/-1;
    
        }
        return ok;
    }
    
    /*
     * Rewind directory stream to beginning.
     */
    static void
    rewinddir(
        DIR* dirp)
    {
        /* Rewind wide-character string directory stream */
        _wrewinddir (dirp->wdirp);
    }
    
    /*
     * Scan directory for entries.
     */
    static int
    scandir(
        const char *dirname,
        struct dirent ***namelist,
        int (*filter)(const struct dirent*),
        int (*compare)(const struct dirent**, const struct dirent**))
    {
        struct dirent **files = NULL;
        size_t size = 0;
        size_t allocated = 0;
        const size_t init_size = 1;
        DIR *dir = NULL;
        struct dirent *entry;
        struct dirent *tmp = NULL;
        size_t i;
        int result = 0;
    
        /* Open directory stream */
        dir = opendir (dirname);
        if (dir) {
    
            /* Read directory entries to memory */
            while (1) {
    
                /* Enlarge pointer table to make room for another pointer */
                if (size >= allocated) {
                    void *p;
                    size_t num_entries;
    
                    /* Compute number of entries in the enlarged pointer table */
                    if (size < init_size) {
                        /* Allocate initial pointer table */
                        num_entries = init_size;
                    } else {
                        /* Double the size */
                        num_entries = size * 2;
                    }
    
                    /* Allocate first pointer table or enlarge existing table */
                    p = realloc (files, sizeof (void*) * num_entries);
                    if (p != NULL) {
                        /* Got the memory */
                        files = (dirent**) p;
                        allocated = num_entries;
                    } else {
                        /* Out of memory */
                        result = -1;
                        break;
                    }
    
                }
    
                /* Allocate room for temporary directory entry */
                if (tmp == NULL) {
                    tmp = (struct dirent*) malloc (sizeof (struct dirent));
                    if (tmp == NULL) {
                        /* Cannot allocate temporary directory entry */
                        result = -1;
                        break;
                    }
                }
    
                /* Read directory entry to temporary area */
                if (readdir_r (dir, tmp, &entry) == /*OK*/0) {
    
                    /* Did we get an entry? */
                    if (entry != NULL) {
                        int pass;
    
                        /* Determine whether to include the entry in result */
                        if (filter) {
                            /* Let the filter function decide */
                            pass = filter (tmp);
                        } else {
                            /* No filter function, include everything */
                            pass = 1;
                        }
    
                        if (pass) {
                            /* Store the temporary entry to pointer table */
                            files[size++] = tmp;
                            tmp = NULL;
    
                            /* Keep up with the number of files */
                            result++;
                        }
    
                    } else {
    
                        /*
                         * End of directory stream reached => sort entries and
                         * exit.
                         */
                        qsort (files, size, sizeof (void*),
                            (int (*) (const void*, const void*)) compare);
                        break;
    
                    }
    
                } else {
                    /* Error reading directory entry */
                    result = /*Error*/ -1;
                    break;
                }
    
            }
    
        } else {
            /* Cannot open directory */
            result = /*Error*/ -1;
        }
    
        /* Release temporary directory entry */
        free (tmp);
    
        /* Release allocated memory on error */
        if (result < 0) {
            for (i = 0; i < size; i++) {
                free (files[i]);
            }
            free (files);
            files = NULL;
        }
    
        /* Close directory stream */
        if (dir) {
            closedir (dir);
        }
    
        /* Pass pointer table to caller */
        if (namelist) {
            *namelist = files;
        }
        return result;
    }
    
    /* Alphabetical sorting */
    static int
    alphasort(
        const struct dirent **a, const struct dirent **b)
    {
        return strcoll ((*a)->d_name, (*b)->d_name);
    }
    
    /* Sort versions */
    static int
    versionsort(
        const struct dirent **a, const struct dirent **b)
    {
        /* FIXME: implement strverscmp and use that */
        return alphasort (a, b);
    }
    
    /* Convert multi-byte string to wide character string */
    static int
    dirent_mbstowcs_s(
        size_t *pReturnValue,
        wchar_t *wcstr,
        size_t sizeInWords,
        const char *mbstr,
        size_t count)
    {
        int error;
    
    #if defined(_MSC_VER)  &&  _MSC_VER >= 1400
    
        /* Microsoft Visual Studio 2005 or later */
        error = mbstowcs_s (pReturnValue, wcstr, sizeInWords, mbstr, count);
    
    #else
    
        /* Older Visual Studio or non-Microsoft compiler */
        size_t n;
    
        /* Convert to wide-character string (or count characters) */
        n = mbstowcs (wcstr, mbstr, sizeInWords);
        if (!wcstr  ||  n < count) {
    
            /* Zero-terminate output buffer */
            if (wcstr  &&  sizeInWords) {
                if (n >= sizeInWords) {
                    n = sizeInWords - 1;
                }
                wcstr[n] = 0;
            }
    
            /* Length of resulting multi-byte string WITH zero terminator */
            if (pReturnValue) {
                *pReturnValue = n + 1;
            }
    
            /* Success */
            error = 0;
    
        } else {
    
            /* Could not convert string */
            error = 1;
    
        }
    
    #endif
        return error;
    }
    
    /* Convert wide-character string to multi-byte string */
    static int
    dirent_wcstombs_s(
        size_t *pReturnValue,
        char *mbstr,
        size_t sizeInBytes, /* max size of mbstr */
        const wchar_t *wcstr,
        size_t count)
    {
        int error;
    
    #if defined(_MSC_VER)  &&  _MSC_VER >= 1400
    
        /* Microsoft Visual Studio 2005 or later */
        error = wcstombs_s (pReturnValue, mbstr, sizeInBytes, wcstr, count);
    
    #else
    
        /* Older Visual Studio or non-Microsoft compiler */
        size_t n;
    
        /* Convert to multi-byte string (or count the number of bytes needed) */
        n = wcstombs (mbstr, wcstr, sizeInBytes);
        if (!mbstr  ||  n < count) {
    
            /* Zero-terminate output buffer */
            if (mbstr  &&  sizeInBytes) {
                if (n >= sizeInBytes) {
                    n = sizeInBytes - 1;
                }
                mbstr[n] = '\0';
            }
    
            /* Length of resulting multi-bytes string WITH zero-terminator */
            if (pReturnValue) {
                *pReturnValue = n + 1;
            }
    
            /* Success */
            error = 0;
    
        } else {
    
            /* Cannot convert string */
            error = 1;
    
        }
    
    #endif
        return error;
    }
    
    /* Set errno variable */
    static void
    dirent_set_errno(
        int error)
    {
    #if defined(_MSC_VER)  &&  _MSC_VER >= 1400
    
        /* Microsoft Visual Studio 2005 and later */
        _set_errno (error);
    
    #else
    
        /* Non-Microsoft compiler or older Microsoft compiler */
        errno = error;
    
    #endif
    }
    
    
    #ifdef __cplusplus
    }
    #endif
    #endif /*DIRENT_H*/
    
    
    
    
    展开全文
  • dirent.hdirent.c下载

    千次阅读 2019-02-24 09:58:15
    从github down了一个工程,MS编译报找不到direct.h,网上搜索,借鉴https://blog.csdn.net/yapingxin/article/details/51444133和http://www.two-sdg.demon.co.uk/curbralan/code/dirent/dirent.html,下载对应代码...

    从github down了一个工程,MS编译报找不到direct.h,网上搜索,借鉴https://blog.csdn.net/yapingxin/article/details/51444133http://www.two-sdg.demon.co.uk/curbralan/code/dirent/dirent.html,下载对应代码,添加到工程中,将问题解决。下面贴出.c和.h。

    direct.cpp

    /*
    
        Implementation of POSIX directory browsing functions and types for Win32.
    
        Author:  Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com)
        History: Created March 1997. Updated June 2003 and July 2012.
        Rights:  See end of file.
    
    */
    
    #include <dirent.h>
    #include <errno.h>
    #include <io.h> /* _findfirst and _findnext set errno iff they return -1 */
    #include <stdlib.h>
    #include <string.h>
    
    #ifdef __cplusplus
    extern "C"
    {
    #endif
    
    typedef ptrdiff_t handle_type; /* C99's intptr_t not sufficiently portable */
    
    struct DIR
    {
        handle_type         handle; /* -1 for failed rewind */
        struct _finddata_t  info;
        struct dirent       result; /* d_name null iff first time */
        char                *name;  /* null-terminated char string */
    };
    
    DIR *opendir(const char *name)
    {
        DIR *dir = 0;
    
        if(name && name[0])
        {
            size_t base_length = strlen(name);
            const char *all = /* search pattern must end with suitable wildcard */
                strchr("/\\", name[base_length - 1]) ? "*" : "/*";
    
            if((dir = (DIR *) malloc(sizeof *dir)) != 0 &&
               (dir->name = (char *) malloc(base_length + strlen(all) + 1)) != 0)
            {
                strcat(strcpy(dir->name, name), all);
    
                if((dir->handle =
                    (handle_type) _findfirst(dir->name, &dir->info)) != -1)
                {
                    dir->result.d_name = 0;
                }
                else /* rollback */
                {
                    free(dir->name);
                    free(dir);
                    dir = 0;
                }
            }
            else /* rollback */
            {
                free(dir);
                dir   = 0;
                errno = ENOMEM;
            }
        }
        else
        {
            errno = EINVAL;
        }
    
        return dir;
    }
    
    int closedir(DIR *dir)
    {
        int result = -1;
    
        if(dir)
        {
            if(dir->handle != -1)
            {
                result = _findclose(dir->handle);
            }
    
            free(dir->name);
            free(dir);
        }
    
        if(result == -1) /* map all errors to EBADF */
        {
            errno = EBADF;
        }
    
        return result;
    }
    
    struct dirent *readdir(DIR *dir)
    {
        struct dirent *result = 0;
    
        if(dir && dir->handle != -1)
        {
            if(!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1)
            {
                result         = &dir->result;
                result->d_name = dir->info.name;
            }
        }
        else
        {
            errno = EBADF;
        }
    
        return result;
    }
    
    void rewinddir(DIR *dir)
    {
        if(dir && dir->handle != -1)
        {
            _findclose(dir->handle);
            dir->handle = (handle_type) _findfirst(dir->name, &dir->info);
            dir->result.d_name = 0;
        }
        else
        {
            errno = EBADF;
        }
    }
    
    #ifdef __cplusplus
    }
    #endif
    
    /*
    
        Copyright Kevlin Henney, 1997, 2003, 2012. All rights reserved.
    
        Permission to use, copy, modify, and distribute this software and its
        documentation for any purpose is hereby granted without fee, provided
        that this copyright and permissions notice appear in all copies and
        derivatives.
        
        This software is supplied "as is" without express or implied warranty.
    
        But that said, if there are any problems please get in touch.
    
    */

    direct.h

    #ifndef DIRENT_INCLUDED
    #define DIRENT_INCLUDED
    
    /*
    
        Declaration of POSIX directory browsing functions and types for Win32.
    
        Author:  Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com)
        History: Created March 1997. Updated June 2003.
        Rights:  See end of file.
        
    */
    
    #ifdef __cplusplus
    extern "C"
    {
    #endif
    
    typedef struct DIR DIR;
    
    struct dirent
    {
        char *d_name;
    };
    
    DIR           *opendir(const char *);
    int           closedir(DIR *);
    struct dirent *readdir(DIR *);
    void          rewinddir(DIR *);
    
    /*
    
        Copyright Kevlin Henney, 1997, 2003. All rights reserved.
    
        Permission to use, copy, modify, and distribute this software and its
        documentation for any purpose is hereby granted without fee, provided
        that this copyright and permissions notice appear in all copies and
        derivatives.
        
        This software is supplied "as is" without express or implied warranty.
    
        But that said, if there are any problems please get in touch.
    
    */
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif

     

    展开全文
  • dirent.h windows安装

    2020-06-01 02:57:17
      进入下载页面后选择最新的dirent.h文件,目前最新的是dirent-1.21.zip,下载完成后解压,将include文件夹下的dirent.h文件复制到VS安装目录下,比如VS2013,就复制到"VC\include"下面,VS2019则要复制到"\VC\...
  • C语言中的dirent.h说明

    2020-11-19 17:26:56
    dirent.h是用于目录操作的头文件,linux 默认在/usr/include目录下(会自动包含其他文件),常见的方法如下: opendir() 打开目录,并返回句柄 readdir() 读取句柄,返回dirent结构体 telldir() 返回当前指针...
  • 1: #path:要遍历的文件夹路径 ...dirent.h> void GetFileNames(string path, vector<string>& filenames) { DIR *pDir; struct dirent* ptr; if (!(pDir = opendir(path.c_str()))) ...
  • windows兼容dirent.h

    2019-09-23 12:46:42
    Error 4 error C1083: Cannot open include file: 'dirent.h': No such file or directory F <dirent.h>是一个应用程序接口,主要用于文件系统的目录读取操作,主要提供了几个目录数据读取函数,参见opengroup....
  • PaddleLite在windows下编译需要的dirent.h文件
  • LINUX下历遍目录的方法一般是这样的 打开目录-》读取-》关闭目录 相关函数是 ...dirent.h> DIR *opendir(const char *dirname); struct dirent *readdir(DIR *dirp); int closedir(DIR *dirp...
  • 在windows7下给vs2015配置dirent.h头文件

    千次阅读 2019-06-25 14:47:15
    dirent.h头文件简介 dirent是使程序员操作列表和文件夹的应用程序接口(API)。简单说,使用dirent可以对系统内的文件夹以及其中的内容进行操作和修改。包括文件夹内列表的显示,内容读取等。在vs2015环境下,需要...
  • 头文件dirent.h

    2018-02-27 20:22:00
    dirent.h>是POSIX.1标准定义的unix类目录操作的头文件,包含了许多UNIX系统服务的函数原型,例如opendir函数、readdir函数。 opendir函数: DIR *opendir(const char *pathname);返回值:若成功则返回指针,若...
  • dirent.h&gt;是一个应用程序接口,主要用于文件系统的目录读取操作,主要提供了几个目录数据读取函数,参见opengroup.org&lt;dirent.h&gt;int closedir(DIR *);//关闭目录 DIR *opendir(const char *);//...
  • dirent在windows下MSVC兼容的dirent.h

    千次阅读 2018-01-28 22:21:17
     dirent,LINUX系统下的一个头文件,在这个目录下/usr/include,为了获取某文件夹目录内容,所使用的结构体。 引用头文件#include 是一个应用程序接口,主要用于文件系统的目录读取操作,主要提供了几个目录...
  • MFC CvvImage.h CvvImage.cpp, dirent.h头文件 可参考博客: http://blog.csdn.net/wgf5845201314/article/details/78186178
  • 目录1 “dirent.h”: No such file or directory2 只需要把下面的代码保存dirent.h即可,直接放在工程目录下。 1 “dirent.h”: No such file or directory 在windows下的VS2017/2019编译器中,发现无法打开“dirent...
  • vc6.0头文件dirent.h

    2019-03-04 15:26:35
    vc6.0头文件的dirent.h。需要时可以使用。
  • 头文件 dirent.h 定义了文件类型;enum{ DT_UNKNOWN = 0, //未知类型 DT_FIFO = 1, //first in, first out 类似于管道, 有名管道 DT_CHR = 2, //字符设备文件 DT_DIR = 4, //目录 DT...
  • 将https://github.com/tronkko/dirent,下的include的dirent.h拷贝到当前工程的目录下。 在这个工程中,将directory字符串转换为宽字节的时候,如果目录是汉字的时候会出现问题。 解决方法: #include &lt;...
  • #include #if _WIN32 ...#include "dirent.h" #else #include #include #endif //window 下载http://www.softagalleria.net/download/dirent/dirent-1.21.zip int main(int argc, char *argv[]

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,452
精华内容 4,580
关键字:

dirent.h