C++遍历目录，并把目录里超过7天的文件删除(跨平台windows&linux)

C++遍历目录，并把目录里超过7天的文件删除，适用于项目里删除过期的日志，或者视频文件。

在windows和linux下测试通过。

windows测试结果：

linux测试结果：

源码：

 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "dirent.h"
 #include <sys/stat.h>
 #include <errno.h>
 #ifdef WIN32

 #else
     #include <unistd.h>
 #endif

 static int find_directory (const char *dirname);

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

     //循环遍历命令行里的每个目录
     i = ;
     while (i < argc) {
         result = find_directory (argv[i]);
         if (result == -) {
             exit (EXIT_FAILURE);
         }
         i++;
     }

     //如果命令行参数为空，则遍历当前工作目录
     if (argc == ) {
         find_directory (".");
     }
     return EXIT_SUCCESS;
 }

 //删除7天前的文件
 int RemoveFile( char* filename )
 {
    int result;
    //errno_t errno;
    //获取文件信息
 #ifdef WIN32
    struct _stat buf;
    result = _stat(filename, &buf);
 #else
    struct stat buf;
    result = stat(filename, &buf);
 #endif

    if( result !=  )
    {
       perror( "Problem getting information" );
       switch (errno)
       {
          case ENOENT:
            printf("File %s not found.\n", filename);
            break;
          case EINVAL:
            printf("Invalid parameter to _stat.\n");
            break;
          default:
            /* Should never be reached. */
            printf("Unexpected error in _stat.\n");
       }
       return -;
    }
    else
    {
       // Output some of the statistics:
       printf( "File size     : %ld\n", buf.st_size );
       printf( "Drive         : %c:\n", buf.st_dev + 'A' );

       time_t t;
       tzset(); /*tzset()*/
       t = time(NULL);
       if((t - buf.st_mtime) > )//604800是7天的秒数，下面是删除超过7天的文件
       {
         remove(filename);
         printf("remove file : %s \n" ,filename);
       }
       return ;
    }

 }

 //遍历子目录和目录中的文件
 static int find_directory(const char *dirname)
 {
     DIR *dir;
     char buffer[PATH_MAX + ];
     char *p = buffer;
     const char *src;
     char *end = &buffer[PATH_MAX];
     int result; //返回结果

     //copy目录名到buffer
     src = dirname;
     while (p < end  &&  *src != '\0') {
         *p++ = *src++;
     }
     *p = '\0';

     //打开目录
     dir = opendir (dirname);
     if (dir != NULL) {
         struct dirent *ent;

         while ((ent = readdir (dir)) != NULL) {//这里返回的是当前目录.
             char *q = p;
             char c;

             //获得目录的最后一个字符
             if (buffer < q) {
                 c = q[-];
             } else {
                 c = ':';
             }

             //在当前给出的目录下加上/
             if (c != ':'  &&  c != '/'  &&  c != '\\') {
                 *q++ = '/';
             }

             //把文件名附加在后面
             src = ent->d_name; //src 为根目录.
             while (q < end  &&  *src != '\0') {
                 *q++ = *src++;
             }
             *q = '\0';

             //根据是否是文件还是目录来选择操作
             switch (ent->d_type) {
             case DT_LNK:
             case DT_REG:
                 //如果是文件
                 printf ("%s\n", buffer);
                 RemoveFile(buffer);
                 break;

             case DT_DIR:
                 //如果是目录
                 if (strcmp (ent->d_name, ".") !=
                         &&  strcmp (ent->d_name, "..") != ) {
                     find_directory (buffer);
                 }
                 break;

             default:
                 /* Ignore device entries */
                 /*NOP*/;
             }

         }

         closedir (dir);
         result = ;

     } else {
         //目录打不开
         printf ("Cannot open directory %s\n", dirname);
         result = -;
     }

     return result;
 }

dirent.h文件代码如下：

 /*
  * dirent.h - dirent API for Microsoft Visual Studio
  *
  * Copyright (C) 2006-2012 Toni Ronkko
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * ``Software''), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  *
  * $Id: dirent.h,v 1.20 2014/03/19 17:52:23 tronkko Exp $
  */
 #ifndef DIRENT_H
 #define DIRENT_H

 /*
  * Define architecture flags so we don't need to include windows.h.
  * Avoiding windows.h makes it simpler to use windows sockets in conjunction
  * with dirent.h.
  */
 #if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_IX86)
 #   define _X86_
 #endif
 #if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_AMD64)
 #define _AMD64_
 #endif

 #include <stdio.h>
 #include <stdarg.h>
 #include <windef.h>
 #include <winbase.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() */
 #if !defined(S_IFMT)
 #   define S_IFMT   _S_IFMT                     /* File type mask */
 #endif
 #if !defined(S_IFDIR)
 #   define S_IFDIR  _S_IFDIR                    /* Directory */
 #endif
 #if !defined(S_IFCHR)
 #   define S_IFCHR  _S_IFCHR                    /* Character device */
 #endif
 #if !defined(S_IFFIFO)
 #   define S_IFFIFO _S_IFFIFO                   /* Pipe */
 #endif
 #if !defined(S_IFREG)
 #   define S_IFREG  _S_IFREG                    /* Regular file */
 #endif
 #if !defined(S_IREAD)
 #   define S_IREAD  _S_IREAD                    /* Read permission */
 #endif
 #if !defined(S_IWRITE)
 #   define S_IWRITE _S_IWRITE                   /* Write permission */
 #endif
 #if !defined(S_IEXEC)
 #   define S_IEXEC  _S_IEXEC                    /* Execute permission */
 #endif
 #if !defined(S_IFIFO)
 #   define S_IFIFO _S_IFIFO                     /* Pipe */
 #endif
 #if !defined(S_IFBLK)
 #   define S_IFBLK                             /* Block device */
 #endif
 #if !defined(S_IFLNK)
 #   define S_IFLNK                             /* Link */
 #endif
 #if !defined(S_IFSOCK)
 #   define S_IFSOCK                            /* Socket */
 #endif

 #if defined(_MSC_VER)
 #   define S_IRUSR  S_IREAD                     /* Read user */
 #   define S_IWUSR  S_IWRITE                    /* Write user */
 #   define S_IXUSR                             /* Execute user */
 #   define S_IRGRP                             /* Read group */
 #   define S_IWGRP                             /* Write group */
 #   define S_IXGRP                             /* Execute group */
 #   define S_IROTH                             /* Read others */
 #   define S_IWOTH                             /* Write others */
 #   define S_IXOTH                             /* Execute others */
 #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.
  */
 #define    S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
 #define    S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)
 #define    S_ISREG(mode)  (((mode) & S_IFMT) == S_IFREG)
 #define    S_ISLNK(mode)  (((mode) & S_IFMT) == S_IFLNK)
 #define    S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
 #define    S_ISCHR(mode)  (((mode) & S_IFMT) == S_IFCHR)
 #define    S_ISBLK(mode)  (((mode) & S_IFMT) == S_IFBLK)

 /* Return the exact length of d_namlen without zero terminator */
 #define _D_EXACT_NAMLEN(p) ((p)->d_namlen)

 /* Return number of bytes needed to store d_namlen */
 #define _D_ALLOC_NAMLEN(p) (PATH_MAX)

 #ifdef __cplusplus
 extern "C" {
 #endif

 /* Wide-character version */
 struct _wdirent {
     long d_ino;                                 /* Always zero */
     unsigned short d_reclen;                    /* Structure size */
     size_t d_namlen;                            /* Length of name without \0 */
     int d_type;                                 /* File type */
     wchar_t d_name[PATH_MAX];                   /* File name */
 };
 typedef struct _wdirent _wdirent;

 struct _WDIR {
     struct _wdirent ent;                        /* Current directory entry */
     WIN32_FIND_DATAW data;                      /* Private file data */
     int cached;                                 /* True if data is valid */
     HANDLE handle;                              /* Win32 search handle */
     wchar_t *patt;                              /* Initial directory name */
 };
 typedef struct _WDIR _WDIR;

 static _WDIR *_wopendir (const wchar_t *dirname);
 static struct _wdirent *_wreaddir (_WDIR *dirp);
 static int _wclosedir (_WDIR *dirp);
 static void _wrewinddir (_WDIR* dirp);

 /* For compatibility with Symbian */
 #define wdirent _wdirent
 #define WDIR _WDIR
 #define wopendir _wopendir
 #define wreaddir _wreaddir
 #define wclosedir _wclosedir
 #define wrewinddir _wrewinddir

 /* Multi-byte character versions */
 struct dirent {
     long d_ino;                                 /* Always zero */
     unsigned short d_reclen;                    /* Structure size */
     size_t d_namlen;                            /* Length of name without \0 */
     int d_type;                                 /* File type */
     char d_name[PATH_MAX];                      /* File name */
 };
 typedef struct dirent dirent;

 struct DIR {
     struct dirent ent;
     struct _WDIR *wdirp;
 };
 typedef struct DIR DIR;

 static DIR *opendir (const char *dirname);
 static struct dirent *readdir (DIR *dirp);
 static int closedir (DIR *dirp);
 static void rewinddir (DIR* dirp);

 /* 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 = NULL;
     int error;

     /* Must have directory name */
     if (dirname == NULL  ||  dirname[] == '\0') {
         dirent_set_errno (ENOENT);
         return NULL;
     }

     /* Allocate new _WDIR structure */
     dirp = (_WDIR*) malloc (sizeof (struct _WDIR));
     if (dirp != NULL) {
         DWORD n;

         /* Reset _WDIR structure */
         dirp->handle = INVALID_HANDLE_VALUE;
         dirp->patt = NULL;
         dirp->cached = ;

         /* Compute the length of full path plus zero terminator */
         n = GetFullPathNameW (dirname, , NULL, NULL);

         /* Allocate room for absolute directory name and search pattern */
         dirp->patt = (wchar_t*) malloc (sizeof (wchar_t) * n + );
         if (dirp->patt) {

             /*
              * 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().
              */
             n = GetFullPathNameW (dirname, n, dirp->patt, NULL);
             if (n > ) {
                 wchar_t *p;

                 /* Append search pattern \* to the directory name */
                 p = dirp->patt + n;
                 if (dirp->patt < p) {
                     switch (p[-]) {
                     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)) {
                     /* Directory stream opened successfully */
                     error = ;
                 } else {
                     /* Cannot retrieve first entry */
                     error = ;
                     dirent_set_errno (ENOENT);
                 }

             } else {
                 /* Cannot retrieve full path name */
                 dirent_set_errno (ENOENT);
                 error = ;
             }

         } else {
             /* Cannot allocate memory for search pattern */
             error = ;
         }

     } else {
         /* Cannot allocate _WDIR structure */
         error = ;
     }

     /* Clean up in case of error */
     if (error  &&  dirp) {
         _wclosedir (dirp);
         dirp = NULL;
     }

     return dirp;
 }

 /*
  * Read next directory entry.  The directory entry is returned in dirent
  * structure in the d_name field.  Individual directory entries returned by
  * this function include regular files, sub-directories, pseudo-directories
  * "." and ".." as well as volume labels, hidden files and system files.
  */
 static struct _wdirent*
 _wreaddir(
     _WDIR *dirp)
 {
     WIN32_FIND_DATAW *datap;
     struct _wdirent *entp;

     /* Read next directory entry */
     datap = dirent_next (dirp);
     if (datap) {
         size_t n;
         DWORD attr;

         /* Pointer to directory entry to return */
         entp = &dirp->ent;

         /*
          * 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 = ;
         while (n +  < PATH_MAX  &&  datap->cFileName[n] != ) {
             entp->d_name[n] = datap->cFileName[n];
             n++;
         }
         dirp->ent.d_name[n] = ;

         /* Length of file name excluding zero terminator */
         entp->d_namlen = n;

         /* File type */
         attr = datap->dwFileAttributes;
         if ((attr & FILE_ATTRIBUTE_DEVICE) != ) {
             entp->d_type = DT_CHR;
         } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != ) {
             entp->d_type = DT_DIR;
         } else {
             entp->d_type = DT_REG;
         }

         /* Reset dummy fields */
         entp->d_ino = ;
         entp->d_reclen = sizeof (struct _wdirent);

     } else {

         /* Last directory entry read */
         entp = NULL;

     }

     return entp;
 }

 /*
  * 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);
             dirp->handle = INVALID_HANDLE_VALUE;
         }

         /* Release search pattern */
         if (dirp->patt) {
             free (dirp->patt);
             dirp->patt = NULL;
         }

         /* Release directory structure */
         free (dirp);
         ok = /*success*/;

     } else {
         /* Invalid directory stream */
         dirent_set_errno (EBADF);
         ok = /*failure*/-;
     }
     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;

     /* Open directory and retrieve the first entry */
     dirp->handle = FindFirstFileW (dirp->patt, &dirp->data);
     if (dirp->handle != INVALID_HANDLE_VALUE) {

         /* a directory entry is now waiting in memory */
         datap = &dirp->data;
         dirp->cached = ;

     } else {

         /* Failed to re-open directory: no directory entry in memory */
         dirp->cached = ;
         datap = NULL;

     }
     return datap;
 }

 /* Get next directory entry (internal) */
 static WIN32_FIND_DATAW*
 dirent_next(
     _WDIR *dirp)
 {
     WIN32_FIND_DATAW *p;

     /* Get next directory entry */
     if (dirp->cached != ) {

         /* A valid directory entry already in memory */
         p = &dirp->data;
         dirp->cached = ;

     } 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 occured */
             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;
     int error;

     /* Must have directory name */
     if (dirname == NULL  ||  dirname[] == '\0') {
         dirent_set_errno (ENOENT);
         return NULL;
     }

     /* Allocate memory for DIR structure */
     dirp = (DIR*) malloc (sizeof (struct DIR));
     if (dirp) {
         wchar_t wname[PATH_MAX];
         size_t n;

         /* Convert directory name to wide-character string */
         error = dirent_mbstowcs_s (&n, wname, PATH_MAX, dirname, PATH_MAX);
         if (!error) {

             /* Open directory stream using wide-character name */
             dirp->wdirp = _wopendir (wname);
             if (dirp->wdirp) {
                 /* Directory stream opened */
                 error = ;
             } else {
                 /* Failed to open directory stream */
                 error = ;
             }

         } else {
             /*
              * 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.
              */
             error = ;
         }

     } else {
         /* Cannot allocate DIR structure */
         error = ;
     }

     /* Clean up in case of error */
     if (error  &&  dirp) {
         free (dirp);
         dirp = NULL;
     }

     return dirp;
 }

 /*
  * Read next directory entry.
  *
  * When working with text consoles, please note that file names returned by
  * readdir() are represented in the default ANSI code page while any output to
  * console is typically formatted on another code page.  Thus, non-ASCII
  * characters in file names will not usually display correctly on console.  The
  * problem can be fixed in two ways: (1) change the character set of console
  * to 1252 using chcp utility and use Lucida Console font, or (2) use
  * _cprintf function when writing to console.  The _cprinf() will re-encode
  * ANSI strings to the console code page so many non-ASCII characters will
  * display correcly.
  */
 static struct dirent*
 readdir(
     DIR *dirp)
 {
     WIN32_FIND_DATAW *datap;
     struct dirent *entp;

     /* 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, dirp->ent.d_name, PATH_MAX, datap->cFileName, PATH_MAX);

         /*
          * 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') {
             error = dirent_wcstombs_s(
                 &n, dirp->ent.d_name, PATH_MAX,
                 datap->cAlternateFileName, PATH_MAX);
         }

         if (!error) {
             DWORD attr;

             /* Initialize directory entry for return */
             entp = &dirp->ent;

             /* Length of file name excluding zero terminator */
             entp->d_namlen = n - ;

             /* File attributes */
             attr = datap->dwFileAttributes;
             if ((attr & FILE_ATTRIBUTE_DEVICE) != ) {
                 entp->d_type = DT_CHR;
             } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != ) {
                 entp->d_type = DT_DIR;
             } else {
                 entp->d_type = DT_REG;
             }

             /* Reset dummy fields */
             entp->d_ino = ;
             entp->d_reclen = sizeof (struct dirent);

         } else {
             /*
              * Cannot convert file name to multi-byte string so construct
              * an errornous directory entry and return that.  Note that
              * we cannot return NULL as that would stop the processing
              * of directory entries completely.
              */
             entp = &dirp->ent;
             entp->d_name[] = '?';
             entp->d_name[] = '\0';
             entp->d_namlen = ;
             entp->d_type = DT_UNKNOWN;
             entp->d_ino = ;
             entp->d_reclen = ;
         }

     } else {
         /* No more directory entries */
         entp = NULL;
     }

     return entp;
 }

 /*
  * 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*/-;

     }
     return ok;
 }

 /*
  * Rewind directory stream to beginning.
  */
 static void
 rewinddir(
     DIR* dirp)
 {
     /* Rewind wide-character string directory stream */
     _wrewinddir (dirp->wdirp);
 }

 /* 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 - ;
             }
             wcstr[n] = ;
         }

         /* Length of resuting multi-byte string WITH zero terminator */
         if (pReturnValue) {
             *pReturnValue = n + ;
         }

         /* Success */
         error = ;

     } else {

         /* Could not convert string */
         error = ;

     }

 #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 - ;
             }
             mbstr[n] = '\0';
         }

         /* Lenght of resulting multi-bytes string WITH zero-terminator */
         if (pReturnValue) {
             *pReturnValue = n + ;
         }

         /* Success */
         error = ;

     } else {

         /* Cannot convert string */
         error = ;

     }

 #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*/

头文件代码

头文件请参考我的另外一篇博客：

http://www.cnblogs.com/matthew-2013/p/4676112.html