淘宝双十一超级红包 》
C 安全函数
在 C 语言中，为了提高代码的安全性，尤其是防止缓冲区溢出等常见的安全问题，C11 标准引入了一些 "安全函数"，也称为 "Annex K" 标准库函数。这些安全函数主要是标准字符串和内存操作函数的增强版本，通过增加参数（如缓冲区大小）来提供更好的错误检测和处理。
安全函数的特点：
- 缓冲区大小检查：所有的安全函数都要求传入目标缓冲区的大小参数，以防止缓冲区溢出。
- 返回值检查：大多数函数返回
errno_t类型的错误代码，可以检查函数是否成功执行。 - 更好的错误处理：当缓冲区大小不够或出现其他问题时，这些函数会返回错误码，并尝试清空或初始化输出缓冲区。
安全函数在 Visual Studio 等编译器中得到较好的支持，但在一些较老版本的编译器中可能不可用，需要注意兼容性。
以下是 C 中常见的安全函数及其对应的传统函数对比：
1、字符串操作安全函数
strcpy_s：安全版本的 strcpy，复制字符串并检查目标缓冲区大小。
errno_t strcpy_s(char *dest, rsize_t destsz, const char *src);
strcat_s：安全版本的 strcat，将源字符串追加到目标字符串末尾，并检查缓冲区大小。
errno_t strcat_s(char *dest, rsize_t destsz, const char *src);
strncpy_s：安全版本的 strncpy，复制最多 n 个字符，并检查缓冲区大小。
errno_t strncpy_s(char *dest, rsize_t destsz, const char *src, rsize_t count);
strncat_s：安全版本的 strncat，追加最多 n 个字符到目标字符串末尾，并检查缓冲区大小。
errno_t strncat_s(char *dest, rsize_t destsz, const char *src, rsize_t count);
strtok_s：安全版本的 strtok，引入上下文参数，解决线程安全问题。
char *strtok_s(char *str, const char *delim, char **context);
2、格式化输出安全函数
sprintf_s：安全版本的 sprintf，格式化输出到字符串时检查缓冲区大小。
int sprintf_s(char *buffer, rsize_t sizeOfBuffer, const char *format, ...);
snprintf_s：安全版本的 snprintf，格式化输出时限制字符数并检查缓冲区大小。
int snprintf_s(char *buffer, rsize_t sizeOfBuffer, const char *format, ...);
vsprintf_s：安全版本的 vsprintf，接收 va_list 参数列表，并检查缓冲区大小。
int vsprintf_s(char *buffer, rsize_t sizeOfBuffer, const char *format, va_list argptr);
3、内存操作安全函数
memcpy_s：安全版本的 memcpy，复制内存区域时检查目标缓冲区大小。
errno_t memcpy_s(void *dest, rsize_t destsz, const void *src, rsize_t count);
memmove_s：安全版本的 memmove，复制内存区域，允许重叠，并检查目标缓冲区大小。
errno_t memmove_s(void *dest, rsize_t destsz, const void *src, rsize_t count);
memset_s：安全版本的 memset，将指定的字符填充到内存块中，并检查缓冲区大小。
errno_t memset_s(void *dest, rsize_t destsz, int ch, rsize_t count);
4、其他常用安全函数
_itoa_s 和 _ultoa_s：安全版本的整数转换函数，将整数转换为字符串时检查目标缓冲区大小。
errno_t _itoa_s(int value, char *buffer, size_t sizeOfBuffer, int radix); errno_t _ultoa_s(unsigned long value, char *buffer, size_t sizeOfBuffer, int radix);
_strlwr_s 和 _strupr_s：将字符串转换为小写或大写的安全版本。
errno_t _strlwr_s(char *str, size_t numberOfElements); errno_t _strupr_s(char *str, size_t numberOfElements);
实例
以下是使用 C 安全函数进行字符串操作和内存操作的示例，展示它们如何避免常见的缓冲区溢出问题并提供更安全的编程方式。
示例 1：strcpy_s 和 strcat_s
实例
#include <string.h>
int main() {
char dest[20]; // 目标缓冲区大小为 20
const char *src = "Hello, World!";
// 使用 strcpy_s 将 src 复制到 dest
if (strcpy_s(dest, sizeof(dest), src) != 0) {
printf("strcpy_s failed!\n");
return 1; // 返回错误代码
} else {
printf("After strcpy_s: %s\n", dest);
}
// 使用 strcat_s 将 " C Language" 追加到 dest
const char *appendStr = " C Language";
if (strcat_s(dest, sizeof(dest), appendStr) != 0) {
printf("strcat_s failed!\n");
return 1; // 返回错误代码
} else {
printf("After strcat_s: %s\n", dest);
}
return 0;
}
输出:
After strcpy_s: Hello, World! strcat_s failed!
在上述代码中，strcpy_s 成功复制了字符串 "Hello, World!" 到 dest，但由于 dest 的大小为 20，不足以容纳 "Hello, World! C Language"，所以 strcat_s 会检测到缓冲区不足，并返回错误代码。
示例 2：memcpy_s
实例
#include <string.h>
int main() {
char src[] = "Sensitive Data";
char dest[15]; // 目标缓冲区大小为 15
// 使用 memcpy_s 将数据复制到 dest
if (memcpy_s(dest, sizeof(dest), src, strlen(src) + 1) != 0) {
printf("memcpy_s failed!\n");
return 1; // 返回错误代码
} else {
printf("After memcpy_s: %s\n", dest);
}
return 0;
}
输出:
After memcpy_s: Sensitive Data
此示例中，memcpy_s 检查了目标缓冲区 dest 是否足够大来容纳 src 的数据，包括字符串末尾的空字符。如果 destsz 小于 strlen(src) + 1，则函数会返回错误并不会执行内存复制。
示例 3：strtok_s
实例
#include <string.h>
int main() {
char str[] = "apple,orange,banana";
char *token;
char *context = NULL;
// 使用 strtok_s 分割字符串
token = strtok_s(str, ",", &context);
while (token != NULL) {
printf("Token: %s\n", token);
token = strtok_s(NULL, ",", &context);
}
return 0;
}
输出:
Token: apple Token: orange Token: banana
在这个示例中，strtok_s 分割字符串时使用 context 参数来保存上下文信息，从而避免了 strtok 线程不安全的问题。
示例 4：sprintf_s
实例
int main() {
char buffer[50];
int num = 42;
const char *str = "Hello";
// 使用 sprintf_s 格式化字符串并检查缓冲区大小
if (sprintf_s(buffer, sizeof(buffer), "Number: %d, String: %s", num, str) < 0) {
printf("sprintf_s failed!\n");
return 1; // 返回错误代码
} else {
printf("Formatted String: %s\n", buffer);
}
return 0;
}
输出:
Formatted String: Number: 42, String: Hello
在这里，sprintf_s 格式化字符串时，接受缓冲区大小作为参数。如果格式化后的字符串超过了 buffer 的大小，函数会返回错误，从而避免缓冲区溢出。
以上例子展示了使用 C 安全函数进行字符串复制、拼接、内存复制、字符串分割和格式化输出的方式。这些函数提供了对缓冲区大小的检查，显著提高了代码的安全性。