VS 2005 CRT函数的安全性增强版本

[align=center]Security-Enhanced Versions of CRT Functions[/align]
[align=center]（CRT = C Runtime Library = C运行时间库）[/align]
[align=center] [/align]
为微软公司对C/C++语言的扩展，其中的一部分已于2003年提交给ISO作为C/C++标准下一版本的修改建议。
安全CRT函数，在原来函数名后添加了“_s”后缀；一般返回出错代码；并将原来的返回值，作为一个参数，添加到函数输入参数列表的最后；对带缓冲区参数的函数，还添加了表示缓冲区大小的输入参数，以防止溢出。
有关的帮助文档参见URL：
ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.VisualStudio.v80.chs/dv_vccrt/html/f87e5a01-4cb2-4379-9e8f-d4693828c55a.htm
1．类型定义
下面是若干安全函数原型用到的类型定义：
#include <crtdefs.h>
typedef int errno_t;
typedef unsigned short wchar_t;
#ifdef _WIN64
typedef unsigned __int64    size_t;
#else
typedef _W64 unsigned int   size_t;
#endif
2．常用安全CRT函数
下面是若干最常用的安全CRT函数原型：
（说明：红色部分为函数名；函数原型后面是其所在的头文件）
 
char *gets_s( char *buffer, size_t sizeInCharacters); // <stdio.h>
wchar_t *_getws_s( wchar_t *buffer, size_t sizeInCharacters); // <stdio.h> or <wchar.h>
 
errno_t
_itoa_s( int value, char *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h>
errno_t
_itow_s( int value, wchar_t *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h>
errno_t
_ultoa_s( unsigned long value, char *str, size_t sizeOfstr, int radix ); // <stdlib.h>
errno_t
_ultow_s( unsigned long value, wchar_t *str, size_t sizeOfstr, int radix ); // <stdlib.h>
 
int
printf_s( const char *format [, argument]... ); // <stdio.h>
int
wprintf_s( const wchar_t *format [, argument]... ); // <stdio.h> or <wchar.h>
int
scanf_s( const char *format [, argument]... ); // <stdio.h>
int
wscanf_s( const wchar_t *format [, argument]... ); // <stdio.h> or <wchar.h>
int
sprintf_s( char *buffer, size_t sizeOfBuffer, const char *format [, argument] ... ); // <stdio.h>
int
swprintf_s( wchar_t *buffer, size_t sizeOfBuffer, const wchar_t *format [, argument]...); // <stdio.h> or <wchar.h>
int
sscanf_s( const char *buffer, const char *format [, argument ] ...); // <stdio.h>
int
swscanf_s( const wchar_t *buffer, const wchar_t *format [, argument ] ...); // <stdio.h> or <wchar.h>
int fprintf_s( FILE *stream, const char *format [, argument ]...); // <stdio.h>

int
fwscanf_s( FILE *stream, const wchar_t *format [, argument ]... ); // <stdio.h> or <wchar.h>
int
fscanf_s( FILE *stream, const char *format [, argument ]... ); // <stdio.h>
int
fwscanf_s( FILE *stream, const wchar_t *format [, argument ]... ); // <stdio.h> or <wchar.h>
 
errno_t
strcpy_s( char *strDestination, size_t sizeInBytes, const char *strSource ); // <string.h>
errno_t
wcscpy_s( wchar_t *strDestination, size_t sizeInWords, const wchar_t *strSource ); // <string.h> or <wchar.h>
 
errno_t fopen_s( FILE** pFile, const char *filename, const char *mode ); // <stdio.h>

errno_t
_wfopen_s( FILE** pFile, const wchar_t *filename, const wchar_t *mode ); // <stdio.h> or <wchar.h>
 
errno_t
mbstowcs_s( size_t *pConvertedChars, wchar_t *wcstr, size_t sizeInWords, const char *mbstr, size_t count ); // <stdlib.h>
errno_t
wcstombs_s( size_t *pConvertedChars, char *mbstr, size_t sizeInBytes, const wchar_t *wcstr, size_t count ); // <stdlib.h>
 
errno_t rand_s( unsigned int* randomValue); // <stdlib.h>
3．全部安全CRT函数
下面按字母顺序（分组）列出全部安全CRT函数的原型：
（说明：彩色部分为函数名，红色为较为常用的，绿色为不太常用的；函数原型后面是其所在的头文件）
errno_t _access_s( const char *path, int mode ); // <io.h>

errno_t _waccess_s( const wchar_t *path, int mode ); // <io.h>

void *_malloca( size_t size ); // <malloc.h>

errno_t asctime_s( char* buffer, size_t sizeInBytes, const struct tm *_tm ); // <time.h>

errno_t _wasctime_s( wchar_t* buffer, size_t sizeInWords, const struct tm *_tm ); // <time.h>

template <size_t size> errno_t
asctime_s( char (&buffer)[size], const struct tm *_tm ); // <time.h> C++ only
template <size_t size> errno_t
_wasctime_s( wchar_t (&buffer)[size], const struct tm *_tm ); // <time.h> C++ only
void *bsearch_s( const void *key, const void *base, size_t num, size_t width, int ( __cdecl *compare ) ( void *, const void *, const void *), void * context); // <stdio.h>
errno_t
_cgets_s( char *buffer, size_t sizeInBytes, size_t *pSizeRead); // <stdio.h>
errno_t
_cgetws_s( wchar_t *buffer, size_t sizeInWords, size_t *pSizeRead); // <stdio.h> or <wchar.h>
template <size_t size> errno_t
_cgets_s( char (&buffer)[size], size_t *pSizeRead); // <stdio.h> C++ only
template <size_t size> errno_t
_cgetws_s( wchar_t (&buffer)[size], size_t *pSizeRead); // <stdio.h> or <wchar.h> C++ only
errno_t
_chsize_s( int fd, __int64 size ); // <io.h>
errno_t clearerr_s( FILE *stream ); // <stdio.h>

errno_t
_controlfp_s( unsigned int *currentControl, unsigned int newControl, unsigned int mask); // <float.h>
int
_cprintf_s( const char * format [, argument] ... ); // <conio.h>
int
_cprintf_s_l( const char * format, locale_t locale [, argument] ... ); // <conio.h>
int
_cwprintf_s( const wcha
17a50
r * format [, argument] ...); // <conio.h> or <wchar.h>
int
_cwprintf_s_l( const wchar * format, locale_t locale [, argument] ...); // <conio.h> or <wchar.h>
int
_cscanf_s( const char *format [, argument] ... ); // <conio.h>
int
_cscanf_s_l( const char *format, locale_t locale [, argument] ... ); // <conio.h>
int
_cwscanf_s( const wchar_t *format [, argument] ... ); // <conio.h> or <wchar.h>
int
_cwscanf_s_l( const wchar_t *format, locale_t locale [, argument] ... ); // <conio.h> or <wchar.h>
errno_t
ctime_s( char* buffer, size_t sizeInBytes, const time_t *time ); // <time.h>
errno_t
_ctime32_s( char* buffer, size_t sizeInBytes, const __time32_t *time ); // <time.h>
errno_t
_ctime64_s( char* buffer, size_t sizeInBytes, const __time64_t *time ); // <time.h>
errno_t
_wctime_s( wchar_t* buffer, size_t sizeInWords, const time_t *time ); // <time.h> or <wchar.h>
errno_t
_wctime32_s( wchar_t* buffer, size_t sizeInWords, const __time32_t *time ); // <time.h> or <wchar.h>
errno_t
_wctime64_s( wchar_t* buffer, size_t sizeInWords, const __time64_t *time ); // <time.h> or <wchar.h>
template <size_t size> errno_t
_ctime32_s( char (&buffer)[size], const __time32_t *time ); //  <time.h> C++ only
template <size_t size> errno_t
_ctime64_s( char (&buffer)[size], const __time64_t *time); // <time.h> C++ only
template <size_t size> errno_t
_wctime32_s( wchar_t (&buffer)[size], const __time32_t *time ); // <time.h> or <wchar.h> C++ only
template <size_t size> errno_t
_wctime64_s( wchar_t (&buffer)[size], const __time64_t *time ); // <time.h> or <wchar.h> C++ only
errno_t
_ecvt_s( char * _Buffer, size_t _SizeInBytes, double _Value, int _Count, int *_Dec, int *_Sign); // <stdlib.h>
template <size_t size> errno_t
_ecvt_s( char (&_Buffer)[size], double _Value, int _Count, int *_Dec, int *_Sign); // <stdlib.h> C++ only
errno_t fopen_s( FILE** pFile, const char *filename, const char *mode ); // <stdio.h>

errno_t
_wfopen_s( FILE** pFile, const wchar_t *filename, const wchar_t *mode ); // <stdio.h> or <wchar.h>
int fprintf_s( FILE *stream, const char *format [, argument ]...); // <stdio.h>

int _fprintf_s_l( FILE *stream, const char *format, locale_t locale [, argument ]...); // <stdio.h>

int fwprintf_s( FILE *stream, const wchar_t *format [, argument ]...); // <stdio.h> or <wchar.h>

int
_fwprintf_s_l( FILE *stream, const wchar_t *format, locale_t locale [, argument ]…); // <stdio.h> or <wchar.h>
errno_t freopen( FILE** pFile, const char *path, const char *mode, FILE *stream ); // <stdio.h>

errno_t
_wfreopen( FILE** pFile, const wchar_t *path, const wchar_t *mode, FILE *stream ); // <stdio.h> or <wchar.h>
int
fscanf_s( FILE *stream, const char *format [, argument ]... ); // <stdio.h>
int
_fscanf_s_l( FILE *stream, const char *format, locale_t locale [, argument ]... ); // <stdio.h>
int
fwscanf_s( FILE *stream, const wchar_t *format [, argument ]... ); // <stdio.h> or <wchar.h>
int
_fwscanf_s_l( FILE *stream, const wchar_t *format, locale_t locale [, argument ]... ); // <stdio.h> or <wchar.h>
errno_t
_ftime_s( struct _timeb *timeptr ); // <sys/types.h> & <sys/timeb.h>
errno_t
_ftime32_s( struct __timeb32 *timeptr ); // <sys/types.h> & <sys/timeb.h>
errno_t
_ftime64_s( struct __timeb64 *timeptr ); // <sys/types.h> & <sys/timeb.h>
errno_t
_gcvt_s( char *buffer, size_t sizeInBytes, double value, int digits ); // <stdlib.h>
template <size_t cchStr> errno_t
_gcvt_s( char (&buffer)[cchStr], double value, int digits ); // <stdlib.h> C++ only
errno_t
getenv_s( size_t *pReturnValue, char* buffer, size_t sizeInBytes, const char *varname ); // <stdlib.h>
errno_t
_wgetenv_s( size_t *pReturnValue, wchar_t *buffer, size_t sizeInWords, const wchar_t *varname ); // <stdlib.h> or <wchar.h>
template <size_t size> errno_t
getenv_s( size_t *pReturnValue, char (&buffer)[size], const char *varname ); // <stdlib.h> C++ only
template <size_t size> errno_t
_wgetenv_s( size_t *pReturnValue, wchar_t (&buffer)[size], const wchar_t *varname ); // <stdlib.h> or <wchar.h> C++ only
char *gets_s( char *buffer, size_t sizeInCharacters); // <stdio.h>
wchar_t *_getws_s( wchar_t *buffer, size_t sizeInCharacters); // <stdio.h> or <wchar.h>
template <size_t size> char *gets_s( char (&buffer)[size]); // <stdio.h> C++ only
template <size_t size> wchar_t *_getws_s( wchar_t (&buffer)[size]); // <stdio.h> or <wchar.h> C++ only
errno_t
_gmtime_s( struct tm* _tm, const __time_t* time); // <time.h>
errno_t
_gmtime32_s( struct tm* _tm, const __time32_t* time); // <time.h>
errno_t
_gmtime64_s( struct tm* _tm, const __time64_t* time ); // <time.h>
errno_t
_itoa_s( int value, char *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h>
errno_t
_i64toa_s( __int64 value, char *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h>
errno_t
_ui64toa_s( unsigned _int64 value, char *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h>
errno_t
_itow_s( int value, wchar_t *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h>
errno_t
_i64tow_s( __int64 value, wchar_t *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h> or <wchar.h>
errno_t
_ui64tow_s( unsigned __int64 value, wchar_t *buffer, size_t sizeInCharacters, int radix ); // <stdlib.h> or <wchar.h>
template <size_t size> errno_t
_itoa_s( int value, char (&buffer)[size], int radix ); // <stdlib.h> or <wchar.h> C++ only
template <size_t size> errno_t
_itow_s( int value, wchar_t (&buffer)[size], int radix ); // <stdlib.h> or <wchar.h> C++ only
void *_lfind_s( const void *key, const void *base, unsigned int *num, size_t size, int (__cdecl *compare)(void *, const void *, const void *), void * context); // <search.h>
errno_t
_localtime_s( struct tm* _tm, const time_t *time ); // <time.h>
errno_t
_localtime32_s( struct tm* _tm, const time32_t *time ); // <time.h>
errno_t
_localtime64_s( struct tm* _tm, const _time64_t *time ); // <time.h>
void *_lsearch_s( const void *key, void *base, unsigned int *num, size_t size, int (__cdecl *compare)(void *, const void *, const void *), void * context); // <search.h>
errno_t
_ltoa_s( long value, char *str, size_t sizeOfstr, int radix ); // <stdlib.h>
errno_t
_ltow_s( long value, wchar_t *str, size_t sizeOfstr, int radix ); // <stdlib.h>
template <size_t size> errno_t
_ltoa_s( long value, char (&str)[size], int radix ); // <stdlib.h> C++ only
template <size_t size> errno_t
_ltow_s( long value, wchar_t (&str)[size], int radix ); // <stdlib.h> C++ only
errno_t
_makepath_s( char *path, size_t sizeInCharacters, const char *drive, const char *dir, const char *fname, const char *ext ); // <stdlib.h>
errno_t
_wmakepath_s( wchar_t *path, size_t sizeInCharacters, const wchar_t *drive, const wchar_t *dir, const wchar_t *fname, const wchar_t *ext ); // <stdlib.h> or <wchar.h>
template <size_t size> errno_t
_makepath_s( char (&path)[size], const char *drive, const char *dir, const char *fname, const char *ext ); // <stdlib.h> C++ only
template <size_t size> errno_t
_wmakepath_s( wchar_t (&path)[size], const wchar_t *drive, const wchar_t *dir, const wchar_t *fname, const wchar_t *ext ); // <stdlib.h> or <wchar.h> C++ only
errno_t
_mbccpy_s( unsigned char *dest, size_t buffSizeInBytes, int * pCopied, const unsigned char *src ); // <mbctype.h>
errno_t
_mbccpy_s_l( unsigned char *dest, size_t buffSizeInBytes, int * pCopied, const unsigned char *src, locale_t locale); // <mbctype.h>
template <size_t size> errno_t
_mbccpy_s( unsigned char (&dest)[size], int * pCopied, const unsigned char *src ); // <mbctype.h> C++ only
template <size_t size> errno_t
_mbccpy_s_l( unsigned char (&dest)[size], int * pCopied, const unsigned char *src, locale_t locale); // <mbctype.h> C++ only
errno_t
_mbsnbcat_s( unsigned char *dest, size_t sizeInBytes, const unsigned char *src, size_t count ); // <mbstring.h>
errno_t
_mbsnbcat_s_l( unsigned char *dest, size_t sizeInBytes, const unsigned char *src, size_t count, _locale_t locale); // <mbstring.h>
template <size_t size> errno_t
_mbsnbcat_s( unsigned char (&dest)[size], const unsigned char *src, size_t count ); // <mbstring.h> C++ only
template <size_t size> errno_t
_mbsnbcat_s_l( unsigned char (&dest)[size], const unsigned char *src, size_t count, _locale_t locale); // <mbstring.h> C++ only
errno_t
_mbsnbcpy_s( unsigned char * strDest, size_t sizeInBytes, const unsigned char * strSource, size_t count ); // <mbstring.h>
errno_t
_mbsnbcpy_s_l( unsigned char * strDest, size_t sizeInBytes, const unsigned char * strSource, size_t count, _locale_t locale); // <mbstring.h>
template <size_t size> errno_t
_mbsnbcpy_s( unsigned char (&strDest)[size], const unsigned char * strSource, size_t count ); // <mbstring.h> C++ only
template <size_t size> errno_t
_mbsnbcpy_s_l( unsigned char (&strDest)[size], const unsigned char * strSource, size_t count, _locale_t locale); // <mbstring.h> C++ only
errno_t
mbsrtowcs_s( size_t *pReturnValue, wchar_t *wcstr, size_t sizeOfwcstr, const char **mbstr, size_t count, mbstate_t *mbstate); // <wchar.h>
template <size_t size> errno_t
mbsrtowcs_s( size_t *pReturnValue, wchar_t (&wcstr)[size], const char **mbstr, size_t count, mbstate_t *mbstate); // <wchar.h> C++ only
errno_t
mbstowcs_s( size_t *pConvertedChars, wchar_t *wcstr, size_t sizeInWords, const char *mbstr, size_t count ); // <stdlib.h>
errno_t
_mbstowcs_s_l( size_t *pConvertedChars, wchar_t *wcstr, size_t sizeInWords, const char *mbstr, size_t count, _locale_t locale); // <stdlib.h>
template <size_t size> errno_t
mbstowcs_s( size_t *pConvertedChars, wchar_t (&wcstr)[size], const char *mbstr, size_t count ); // <stdlib.h> C++ only
template <size_t size> errno_t
_mbstowcs_s_l( size_t *pConvertedChars, wchar_t (&wcstr)[size], const char *mbstr, size_t count, _locale_t locale); // <stdlib.h> C++ only
errno_t
memcpy_s( void *dest, size_t sizeInBytes, const void *src, size_t count ); // <memory.h> or <string.h>
errno_t
wmemcpy_s( wchar_t *dest, size_t sizeInWords, const wchar_t *src, size_t count); // <wchar.h>
errno_t
memmove_s( void *dest, size_t sizeInBytes, const void *src, size_t count ); // <string.h>
errno_t
wmemmove_s( wchar_t *dest, size_t sizeInWords, const wchar_t *src, size_t count); // <wchar.h>
errno_t
_mktemp_s( char *template, size_t sizeInChars); // <io.h>
errno_t
_wmktemp_s( wchar_t *template, size_t sizeInChars); // <io.h> or <wchar.h>
template <size_t size> errno_t
_mktemp_s( char (&template)[size]); // <io.h> C++ only
template <size_t size> errno_t
_wmktemp_s( wchar_t (&template)[size]); // <io.h> or <wchar.h> C++ only
int
printf_s( const char *format [, argument]... ); // <stdio.h>
int
_printf_s_l( const char *format, locale_t locale [, argument]... ); // <stdio.h>
int
wprintf_s( const wchar_t *format [, argument]... ); // <stdio.h> or <wchar.h>
int
_wprintf_s_l( const wchar_t *format, locale_t locale [, argument]... ); // <stdio.h> or <wchar.h>
errno_t
_putenv_s( const char *name, const char *value ); // <stdlib.h>
errno_t
_wputenv_s( const wchar_t *name, const wchar_t *value); // <stdlib.h> or <wchar.h>
void
qsort_s( void *base, size_t num, size_t width, int (__cdecl *compare )(void *, const void *, const void *), void * context); // <stdlib.h> & <search.h>
errno_t rand_s( unsigned int* randomValue); // <stdlib.h>
int
scanf_s( const char *format [, argument]... ); // <stdio.h>
int
_scanf_s_l( const char *format, locale_t locale [, argument]... ); // <stdio.h>
int
wscanf_s( const wchar_t *format [, argument]... ); // <stdio.h> or <wchar.h>
int
_wscanf_s_l( const wchar_t *format, locale_t locale [, argument]... ); // <stdio.h> or <wchar.h>
errno_t
_searchenv_s( const char *filename, const char *varname, char *pathname, size_t sizeInBytes); // <stdlib.h>
errno_t
_wsearchenv_s( const wchar_t *filename, const wchar_t *varname, wchar_t *pathname,
   size_t sizeInWords); // <stdlib.h> or <wchar.h>
template <size_t size> errno_t
_searchenv_s( const char *filename, const char *varname, char (&pathname)[size]); // <stdlib.h> C++ only
template <size_t size> errno_t
_wsearchenv_s( const wchar_t *filename, const wchar_t *varname,
   wchar_t (&pathname)[size]); // <stdlib.h> or <wchar.h> C++ only
int
_snprintf_s( char *buffer, size_t sizeOfBuffer, size_t count, const char *format [, argument] ... ); // <stdio.h>
int
_snprintf_s_l( char *buffer, size_t sizeOfBuffer, size_t count, const char *format, locale_t locale [, argument] ... ); // <stdio.h>
int
_snwprintf_s( wchar_t *buffer, size_t sizeOfBuffer, size_t count, const wchar_t *format [, argument] ... ); // <stdio.h> or <wchar.h>
int
_snwprintf_s_l( wchar_t *buffer, size_t sizeOfBuffer, size_t count, const wchar_t *format, locale_t locale [, argument] ... ); // <stdio.h> or <wchar.h>
template <size_t size> int _snprintf_s( char (&buffer)[size], size_t count, const char *format [,
      argument] ... ); // <stdio.h> C++ only
template <size_t size> int
_snwprintf_s( wchar_t (&buffer)[size], size_t count, const wchar_t *format [, argument] ... ); // <stdio.h> or <wchar.h> C++ only
int __cdecl
_snscanf_s( const char * input, size_t length, const char * format, ...); // <stdio.h>
int __cdecl
_snscanf_s_l( const char * input, size_t length, const char * format, locale_t locale, ...); // <stdio.h>
int __cdecl
_snwscanf_s( const wchar_t * input, size_t length, const wchar_t * format, ...); // <stdio.h> or <wchar.h>
int __cdecl
_snwscanf_s_l( const wchar_t * input, size_t length, const wchar_t * format, locale_t locale, …); // <stdio.h> or <wchar.h>
errno_t
_sopen_s( int* pfh, const char *filename, int oflag, int shflag, int pmode); // <io.h>
errno_t
_wsopen_s( int* pfh, const wchar_t *filename, int oflag, int shflag, int pmode); // <io.h> or <wchar.h>
errno_t
_splitpath_s( const char * path, char * drive, size_t driveSizeInCharacters, char * dir, size_t dirSizeInCharacters, char * fname, size_t nameSizeInCharacters, char * ext, size_t extSizeInBytes); // <stdlib.h>
errno_t
_wsplitpath_s( const wchar_t * path, wchar_t * drive, size_t driveSizeInCharacters, wchar_t *dir, size_t dirSizeInCharacters, wchar_t * fname, size_t nameSizeInCharacters, wchar_t * ext, size_t extSizeInCharacters); // <stdlib.h> or <wchar.h>
template <size_t drivesize, size_t dirsize, size_t fnamesize, size_t extsize> errno_t
_splitpath_s( const char *path, char (&drive)[drivesize], char (&dir)[dirsize], char (&fname)[fnamesize], char (&ext)[extsize]); // <stdlib.h> C++ only
template <size_t drivesize, size_t dirsize, size_t fnamesize, size_t extsize> errno_t
_wsplitpath_s( const wchar_t *path, wchar_t (&drive)[size], wchar_t (&dir)[size], wchar_t (&fname)[size], wchar_t (&ext)[size]); // <stdlib.h> or <wchar.h> C++ only
int
sprintf_s( char *buffer, size_t sizeOfBuffer, const char *format [, argument] ... ); // <stdio.h>
int
_sprintf_s_l( char *buffer, size_t sizeOfBuffer, const char *format, locale_t locale [, argument] ... ); // <stdio.h>
int
swprintf_s( wchar_t *buffer, size_t sizeOfBuffer, const wchar_t *format [, argument]...); // <stdio.h> or <wchar.h>
int
_swprintf_s_l( wchar_t *buffer, size_t sizeOfBuffer, const wchar_t *format, locale_t locale [, argument]…); // <stdio.h> or <wchar.h>
template <size_t size> int
sprintf_s( char (&buffer)[size], const char *format [, argument] ... ); // <stdio.h> C++ only
template <size_t size> int
swprintf_s( wchar_t (&buffer)[size], const wchar_t *format [, argument]...); // <stdio.h> or <wchar.h> C++ only
int
sscanf_s( const char *buffer, const char *format [, argument ] ...); // <stdio.h>
int
_sscanf_s_l( const char *buffer, const char *format, locale_t locale [, argument ] ...); // <stdio.h>
int
swscanf_s( const wchar_t *buffer, const wchar_t *format [, argument ] ...); // <stdio.h> or <wchar.h>
int
_swscanf_s_l( const wchar_t *buffer, const wchar_t *format, locale_t locale [, argument ] ...); // <stdio.h> or <wchar.h>
errno_t
strcat_s( char *strDestination, size_t sizeInBytes, const char *strSource ); // <string.h>
errno_t
wcscat_s( wchar_t *strDestination, size_t sizeInWords, const wchar_t *strSource ); // <string.h> or <wchar.h>
errno_t
_mbscat_s( unsigned char *strDestination, size_t sizeInBytes,const unsigned char *strSource ); // <mbstring.h>
template <size_t size> errno_t
strcat_s( char (&strDestination)[size], const char *strSource ); // <string.h> C++ only
template <size_t size> errno_t
wcscat_s( wchar_t (&strDestination)[size], const wchar_t *strSource ); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_mbscat_s( unsigned char (&strDestination)[size], const unsigned char *strSource ); // <mbstring.h> C++ only
errno_t
strcpy_s( char *strDestination, size_t sizeInBytes, const char *strSource ); // <string.h>
errno_t
wcscpy_s( wchar_t *strDestination, size_t sizeInWords, const wchar_t *strSource ); // <string.h> or <wchar.h>
errno_t
_mbscpy_s( unsigned char *strDestination, size_t sizeInBytes, const unsigned char *strSource ); // <mbstring.h>
template <size_t size> errno_t
strcpy_s( char (&strDestination)[size], const char *strSource ); // <string.h> C++ only
template <size_t size> errno_t
wcscpy_s( wchar_t (&strDestination)[size], const wchar_t *strSource ); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_mbscpy_s( unsigned char (&strDestination)[size], const unsigned char *strSource ); // <mbstring.h> C++ only
errno_t _strdate_s( char *buffer, size_t sizeInBytes); // <time.h>
errno_t
_wstrdate_s( wchar_t *buffer, size_t sizeInWords); // <time.h> or <wchar.h>
template <size_t size> errno_t
_strdate_s( char (&buffer)[size]); // <time.h> C++ only
template <size_t size> errno_t
_wstrdate_s( wchar_t (&buffer)[size]); // <time.h> or <wchar.h> C++ only
errno_t
strerror_s( char *buffer, size_t sizeInBytes, int errnum ); // <string.h>
errno_t
_strerror_s( char *buffer, size_t sizeInBytes, const char *strErrMsg ); // <string.h>
errno_t
_wcserror_s( wchar_t *buffer, size_t sizeInWords, int errnum ); // <string.h> or <wchar.h>
errno_t
__wcserror_s( wchar_t *buffer, size_t sizeInWords, const wchar_t *strErrMsg ); // <string.h> or <wchar.h>
template <size_t size> errno_t
strerror_s( char (&buffer)[size], int errnum ); // <string.h> C++ only
template <size_t size> errno_t
_strerror_s( char (&buffer)[size], const char *strErrMsg ); // <string.h> C++ only
template <size_t size> errno_t
_wcserror_s( wchar_t (&buffer)[size], int errnum ); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
__wcserror_s( wchar_t (&buffer)[size], const wchar_t *strErrMsg ); // <string.h> or <wchar.h> C++ only
errno_t
_strlwr_s( char *str, size_t sizeInBytes); // <string.h>
errno_t
_strlwr_s_l( char *str, size_t sizeInBytes, _locale_t locale); // <string.h>
errno_t
_mbslwr_s( unsigned char *str, size_t sizeInBytes); // <string.h> or <wchar.h>
errno_t
_mbslwr_s_l( unsigned char *str, size_t sizeInBytes, _locale_t locale); // <string.h> or <wchar.h>
errno_t
_wcslwr_s( wchar_t *str, size_t sizeInWords); // <string.h> or <wchar.h>
errno_t
_wcslwr_s_l( wchar_t *str, size_t sizeInWords, _locale_t locale); // <string.h> or <wchar.h>
template <size_t size> errno_t
_strlwr_s( char (&str)[size]); // <string.h> C++ only
template <size_t size> errno_t
_strlwr_s_l( char (&str)[size], _locale_t locale); // <string.h> C++ only
template <size_t size> errno_t
_mbslwr_s( unsigned char (&str)[size]); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_mbslwr_s_l( unsigned char (&str)[size], _locale_t locale); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_wcslwr_s( wchar_t (&str)[size]); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_wcslwr_s_l( wchar_t (&str)[size], _locale_t locale); // <string.h> or <wchar.h> C++ only
errno_t
strncat_s( char *strDest, size_t bufferSizeInBytes, const char *strSource, size_t count); // <string.h>
errno_t
_strncat_s_l( char *strDest, size_t bufferSizeInBytes, const char *strSource, size_t count,
   _locale_t locale); // <string.h>
errno_t
wcsncat_s( wchar_t *strDest, size_t bufferSizeInWords, const wchar_t *strSource, size_t count ); // <string.h> or <wchar.h>
errno_t
_wcsncat_s_l( wchar_t *strDest, size_t bufferSizeInWords, const wchar_t *strSource, size_t count, _locale_t locale); // <string.h> or <wchar.h>
errno_t
_mbsncat_s( unsigned char *strDest, size_t bufferSizeInBytes, const unsigned char *strSource, size_t count); // <mbstring.h>
errno_t
_mbsncat_s_l( unsigned char *strDest, size_t bufferSizeInBytes, const unsigned char *strSource, size_t count, _locale_t locale); // <mbstring.h>
template <size_t size> errno_t
strncat_s( char (&strDest)[size], const char *strSource, size_t count); // <string.h> C++ only
template <size_t size> errno_t
_strncat_s_l( char (&strDest)[size], const char *strSource, size_t count, _locale_t locale); // <string.h> C++ only
template <size_t size> errno_t
wcsncat_s( wchar_t (&strDest)[size], const wchar_t *strSource, size_t count ); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_wcsncat_s_l( wchar_t (&strDest)[size], const wchar_t *strSource, size_t count, _locale_t locale); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_mbsncat_s( unsigned char (&strDest)[size], const unsigned char *strSource, size_t count); // <mbstring.h> C++ only
template <size_t size> errno_t
_mbsncat_s_l( unsigned char (&strDest)[size], const unsigned char *strSource, size_t count, _locale_t locale); // <mbstring.h> C++ only
errno_t
strncpy_s( char *strDest, size_t sizeInBytes, const char *strSource, size_t count); // <string.h>
errno_t
_strncpy_s_l( char *strDest, size_t sizeInBytes, const char *strSource, size_t count, _locale_t locale); // <string.h>
errno_t
wcsncpy_s( wchar_t *strDest, size_t sizeInWords, const wchar_t *strSource, size_t count ); // <string.h> or <wchar.h>
errno_t
_wcsncpy_s_l( wchar_t *strDest, size_t sizeInWords, const wchar_t *strSource, size_t count, _locale_t locale); // <string.h> or <wchar.h>
errno_t
_mbsncpy_s( unsigned char *strDest, size_t sizeInBytes, const unsigned char *strSource, size_t count ); // <mbstring.h>
errno_t
_mbsncpy_s_l( unsigned char *strDest, size_t sizeInBytes, const unsigned char *strSource, size_t count, locale_t locale); // <mbstring.h>
template <size_t size> errno_t
strncpy_s( char (&strDest)[size], const char *strSource, size_t count); // <string.h> C++ only
template <size_t size> errno_t
_strncpy_s_l( char (&strDest)[size], const char *strSource, size_t count, _locale_t locale); // <string.h> C++ only
template <size_t size> errno_t
wcsncpy_s( wchar_t (&strDest)[size], const wchar_t *strSource, size_t count ); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_wcsncpy_s_l( wchar_t (&strDest)[size], const wchar_t *strSource, size_t count, _locale_t locale); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_mbsncpy_s( unsigned char (&strDest)[size], const unsigned char *strSource, size_t count ); // <mbstring.h> C++ only
template <size_t size> errno_t
_mbsncpy_s_l( unsigned char (&strDest)[size], const unsigned char *strSource, size_t count, locale_t locale); // <mbstring.h> C++ only
errno_t
_strtime_s( char *buffer, size_t sizeInBytes); // <time.h>
errno_t
_wstrtime_s( wchar_t *buffer, size_t sizeInWords); // <time.h> or <wchar.h>

template <size_t size> errno_t
_strtime_s( char (&buffer)[size]); // <time.h> C++ only
template <size_t size> errno_t
_wstrtime_s( wchar_t (&buffer)[size]); // <time.h> or <wchar.h> C++ only
char *strtok_s( char *strToken, const char *strDelimit, char **context); // <string.h>
char *_strtok_s_l( char *strToken, const char *strDelimit, char **context, _locale_t locale); // <string.h>
wchar_t *wcstok_s( wchar_t *strToken, const wchar_t *strDelimit, wchar_t **context); // <string.h> or <wchar.h>
wchar_t *_wcstok_s_l( wchar_t *strToken, const wchar_t *strDelimit, wchar_t **context, _locale_t locale); // <string.h> or <wchar.h>
unsigned char *_mbstok_s( unsigned char*strToken, const unsigned char *strDelimit, char **context); // <mbstring.h>
unsigned char *_mbstok_s( unsigned char*strToken, const unsigned char *strDelimit, char **context, _locale_t locale); // <mbstring.h>
errno_t
_strupr_s( char *str, size_t sizeInBytes); // <string.h> or <wchar.h>
errno_t
_wcsupr_s( wchar_t * str, size_t sizeInWords); // <string.h> or <wchar.h>
errno_t
_strupr_s_l( char * str, size_t sizeInBytes, _locale_t locale); // <string.h>
errno_t
_wcsupr_s_l( wchar_t * str, size_t sizeInWords, _locale_t locale); // <string.h> or <wchar.h>
errno_t
_mbsupr_s( unsigned char *str, size_t sizeInBytes); // <string.h> or <wchar.h>
errno_t
_mbsupr_s_l( unsigned char *str, size_t sizeInBytes, _locale_t locale); // <string.h> or <wchar.h>
template <size_t size> errno_t
_strupr_s( char (&str)[size]); // <string.h> C++ only
template <size_t size> errno_t
_wcsupr_s( wchar_t (&str)[size]); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_strupr_s_l( char (&str)[size], _locale_t locale); // <string.h> C++ only
template <size_t size> errno_t
_wcsupr_s_l( wchar_t (&str)[size], _locale_t locale); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_mbsupr_s( unsigned char (&str)[size]); // <string.h> or <wchar.h> C++ only
template <size_t size> errno_t
_mbsupr_s_l( unsigned char (&str)[size], _locale_t locale); // <string.h> or <wchar.h> C++ only
errno_t
tmpfile_s( FILE** pFilePtr); // <stdio.h>
errno_t
tmpnam_s( char * str, size_t sizeInChars ); // <stdio.h>
errno_t
_wtmpnam_s( wchar_t *str, size_t sizeInChars ); // <stdio.h> or <wchar.h>
template <size_t size> errno_t
tmpnam_s( char (&str)[size]); // <stdio.h> C++ only
template <size_t size> errno_t
_wtmpnam_s( wchar_t (&str)[size]); // <stdio.h> or <wchar.h> C++ only
errno_t
_ultoa_s( unsigned long value, char *str, size_t sizeOfstr, int radix ); // <stdlib.h>
errno_t
_ultow_s( unsigned long value, wchar_t *str, size_t sizeOfstr, int radix ); // <stdlib.h>
template <size_t size> errno_t
_ultoa_s( unsigned long value, char (&str)[size], int radix ); // <stdlib.h> C++ only
template <size_t size> errno_t
_ultow_s( unsigned long value, wchar_t (&str)[size], int radix ); // <stdlib.h> C++ only
errno_t
_umask_s( int mode, int * pOldMode); // <io.h> & <sys/stat.h> & <sys/types.h>
int
_vcprintf_s( const char* format, va_list argptr); // <conio.h> and <stdarg.h>
int _vcprintf_s_l( const char* format, locale_t locale, va_list argptr); // <conio.h> & <stdarg.h>
int
_vcwprintf_s( const wchar_t* format, va_list argptr); // <conio.h> or <wchar.h>, and <stdarg.h>
int
_vcwprintf_s_l( const wchar_t* format, locale_t locale, va_list argptr); // <conio.h> or <wchar.h>, and <stdarg.h>
int
vfprintf_s( FILE *stream, const char *format, va_list argptr ); // <stdio.h> & <stdarg.h>
int
_vfprintf_s_l( FILE *stream, const char *format, locale_t locale, va_list argptr ); // <stdio.h> & <stdarg.h>
int
vfwprintf_s( FILE *stream, const wchar_t *format, va_list argptr ); // <stdio.h> or <wchar.h>, and <stdarg.h>
int
_vfwprintf_s_l( FILE *stream, const wchar_t *format, locale_t locale, va_list argptr ); // <stdio.h> or <wchar.h>, and <stdarg.h>
int
vprintf_s( const char *format, va_list argptr ); // <stdio.h> & <stdarg.h>
int
_vprintf_s_l( const char *format, locale_t locale, va_list argptr ); // <stdio.h> & <stdarg.h>
int
vwprintf_s( const wchar_t *format, va_list argptr ); // <stdio.h> or <wchar.h>, and <stdarg.h>
int
_vwprintf_s_l( const wchar_t *format, locale_t locale, va_list argptr ); // <stdio.h> or <wchar.h>, and <stdarg.h>
errno_t
wcrtomb_s( size_t *pReturnValue, char *mbchar, size_t sizeOfmbchar, wchar_t *wchar, mbstate_t *mbstate); // <wchar.h>
template <size_t size> errno_t
wcrtomb_s( size_t *pReturnValue, char (&mbchar)[size], wchar_t *wchar, mbstate_t *mbstate); // <wchar.h> C++ only
errno_t
wcsrtombs_s( size_t *pReturnValue, char *mbstr, size_t sizeOfmbstr, const wchar_t **wcstr, sizeof count, mbstate_t *mbstate); // <wchar.h>
template <size_t size> errno_t
wcsrtombs_s( size_t *pReturnValue, char (&mbstr)[size], const wchar_t **wcstr, sizeof count, mbstate_t *mbstate); // <wchar.h> C++ only
errno_t
wcstombs_s( size_t *pConvertedChars, char *mbstr, size_t sizeInBytes, const wchar_t *wcstr, size_t count ); // <stdlib.h>
errno_t
_wcstombs_s_l( size_t *pConvertedChars, char *mbstr, size_t sizeInBytes, const wchar_t *wcstr, size_t count, _locale_t locale); // <stdlib.h>
template <size_t size> errno_t
wcstombs_s( size_t *pConvertedChars, char (&mbstr)[size], const wchar_t *wcstr, size_t count ); // <stdlib.h> C++ only
template <size_t size> errno_t
_wcstombs_s_l( size_t *pConvertedChars, char (&mbstr)[size], const wchar_t *wcstr, size_t count, _locale_t locale); // <stdlib.h> C++ only
errno_t
wctomb_s( int *pRetValue, char *mbchar, size_t sizeInBytes, wchar_t wchar ); // <stdlib.h>
errno_t
_wctomb_s_l( int *pRetValue, char *mbchar, size_t sizeInBytes, wchar_t wchar, _locale_t locale); // <stdlib.h>