【安全函数】从 strlen 到 strlen_s：C 语言字符串长度计算的安全进化

byte轻骑兵

发布于 2026-01-22 08:38:06

880

在 C 语言发展历程中，字符串操作的安全性始终是开发者关注的焦点。strlen () 作为经典的字符串长度计算函数，虽高效却因缺乏边界检查埋下安全隐患。C11 标准引入的 strlen_s () 函数，正是为解决这些安全问题而生。

一、函数简介

1.1 strlen_s () 的核心定位

strlen_s () 是 C11 标准（ISO/IEC 9899:2011）新增的边界检查接口（Bounds Checking Interfaces）之一，定义于<string.h>头文件，其核心功能是在指定的最大范围内计算字符串长度，同时提供空指针检查和边界限制，从根本上避免了传统 strlen () 可能导致的内存越界访问。

与 strlen () 相比，strlen_s () 的革命性改进在于：

引入最大检查范围参数，防止无限遍历内存
明确处理空指针（NULL）情况，避免未定义行为
当字符串未包含终止符时，返回错误而非继续越界

1.2 与 strlen () 的本质区别

特性	strlen()	strlen_s()
标准	C89 及以后	C11 及以后
参数	仅字符串指针	字符串指针 + 最大检查范围
空指针处理	未定义行为（可能崩溃）	定义行为（返回 0 或设置错误）
无终止符情况	越界访问内存	在 maxsize 范围内未找到 '\0' 返回 0
返回值	始终为字符串长度（无符号）	有效长度或 0（错误时）
安全性	低（无边界检查）	高（完整边界检查）

举个直观例子：对于未以 '\0' 结尾的字符数组，两者表现截然不同：

char unsafe_str[3] = {'a', 'b', 'c'};  // 无终止符的字符数组
size_t len1 = strlen(unsafe_str);      // 未定义行为：越界访问内存
size_t len2 = strlen_s(unsafe_str, 3); // 安全行为：返回0（3字节内无'\0'）

二、函数原型

2.1 strlen_s () 的标准原型

C11 标准定义的 strlen_s () 原型如下：

size_t strlen_s(const char *str, size_t maxsize);

参数解析：

const char *str：指向待计算长度的字符串指针，const 修饰表明函数不会修改字符串内容
size_t maxsize：最大检查范围（字节数），必须是字符串所在缓冲区的实际大小，超过此范围后函数将停止检查

返回值规则：

若str为 NULL 且maxsize为 0：返回 0（特殊情况，视为空字符串）
若str为 NULL 且maxsize>0：返回 0 并可能设置errno为EINVAL
若在[0, maxsize-1]范围内找到 '\0'：返回从 str 到 '\0' 的字节数（不含 '\0'）
若在[0, maxsize-1]范围内未找到 '\0'：返回 0 并可能设置errno为EILSEQ

2.2 与 strlen () 原型的对比

strlen () 的原型为：

size_t strlen(const char *str);

两者核心差异在于参数数量和错误处理：

strlen () 依赖字符串自身包含的 '\0' 作为终止标志，没有外部边界限制
strlen_s () 通过maxsize参数建立外部边界，即使字符串缺少 '\0' 也能安全终止
strlen () 对所有异常情况（空指针、无终止符）均表现为未定义行为
strlen_s () 对异常情况有明确定义的处理方式，返回可预期的结果

三、函数实现

3.1 strlen_s () 的实现原理（伪代码）

strlen_s () 的核心逻辑是 "双重检查"：同时验证字符串终止符和最大范围，伪代码实现如下：

// 模拟C11标准strlen_s()实现
size_t strlen_s(const char *str, size_t maxsize) {
    // 1. 空指针处理：若str为NULL，需检查maxsize
    if (str == NULL) {
        // 仅当maxsize为0时视为合法空字符串，否则为错误
        if (maxsize == 0) {
            return 0;
        } else {
            errno = EINVAL;  // 设置无效参数错误
            return 0;
        }
    }

    // 2. 空范围处理：maxsize为0且str非空，视为错误
    if (maxsize == 0) {
        errno = EINVAL;
        return 0;
    }

    // 3. 在[0, maxsize-1]范围内查找终止符
    for (size_t i = 0; i < maxsize; i++) {
        if (str[i] == '\0') {
            return i;  // 找到终止符，返回长度
        }
    }

    // 4. 未找到终止符，返回0并设置错误
    errno = EILSEQ;  // 非法字节序列错误
    return 0;
}

3.2 与 strlen () 实现的关键差异

strlen () 的简化实现：

// strlen()的典型实现
size_t strlen(const char *str) {
    const char *ptr = str;
    while (*ptr != '\0') {
        ptr++;
    }
    return ptr - str;
}

两者实现逻辑的核心区别：

边界控制：strlen_s () 有明确的maxsize边界，strlen () 完全依赖内部 '\0'
异常处理：strlen_s () 对空指针和无终止符情况有明确处理，strlen () 则是未定义行为
遍历终止条件：strlen_s () 是 "找到 '\0' 或达到 maxsize"，strlen () 是 "仅找到 '\0'"
错误反馈：strlen_s () 通过返回 0 和设置 errno 提供错误信息，strlen () 无任何错误反馈

下图展示了两者处理无终止符字符串时的内存访问差异：

// 内存布局：char buf[5] = {'a','b','c','d','e'}（无'\0'）
// strlen(buf)的访问范围：buf[0]→buf[1]→buf[2]→buf[3]→buf[4]→buf[5]→...（越界）
// strlen_s(buf,5)的访问范围：buf[0]→buf[1]→buf[2]→buf[3]→buf[4]（终止，返回0）

四、使用场景：安全优先的适用场景

strlen_s () 的设计初衷是增强安全性，以下场景尤其适合使用：

4.1 处理用户输入或不可信数据

用户输入的字符串可能故意缺少终止符（如恶意攻击），此时 strlen_s () 能有效防止缓冲区溢出：

#include <stdio.h>
#include <string.h>
#include <errno.h>

#define INPUT_BUF_SIZE 100

int main() {
    char input[INPUT_BUF_SIZE];
    printf("请输入字符串：");
    fgets(input, INPUT_BUF_SIZE, stdin);  // 最多读取99字符+自动加'\0'

    // 安全计算长度：限制在缓冲区大小内
    size_t len = strlen_s(input, INPUT_BUF_SIZE);
    if (len == 0 && errno == EILSEQ) {
        printf("错误：输入字符串未包含终止符！\n");
        return 1;
    }

    printf("输入长度：%zu\n", len);
    return 0;
}

4.2 操作动态分配的内存

动态内存中的字符串可能因分配错误或篡改导致缺少终止符，strlen_s () 可限定检查范围：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// 安全复制字符串到动态内存
char *safe_strdup(const char *src, size_t src_max) {
    if (src == NULL || src_max == 0) return NULL;

    // 先安全计算源字符串长度
    size_t src_len = strlen_s(src, src_max);
    if (src_len == 0 && errno == EILSEQ) {
        fprintf(stderr, "源字符串无效（无终止符）\n");
        return NULL;
    }

    // 分配内存（+1存储'\0'）
    char *dest = (char*)malloc(src_len + 1);
    if (dest == NULL) return NULL;

    // 复制字符串
    for (size_t i = 0; i <= src_len; i++) {
        dest[i] = src[i];
    }
    return dest;
}

int main() {
    char src[20] = "动态内存安全测试";
    char *dest = safe_strdup(src, sizeof(src));
    
    if (dest != NULL) {
        printf("复制结果：%s（长度：%zu）\n", dest, strlen_s(dest, 100));
        free(dest);
    }
    return 0;
}

4.3 嵌入式系统与关键基础设施

在内存受限或安全性要求极高的场景（如汽车电子、工业控制），strlen_s () 能避免因越界访问导致的系统崩溃：

// 嵌入式系统中的安全字符串处理
#include <string.h>

#define DEVICE_ID_MAX 16  // 设备ID最大长度

// 验证设备ID合法性
int validate_device_id(const char *id) {
    // 检查ID长度是否在1-15之间（含终止符共16字节）
    size_t len = strlen_s(id, DEVICE_ID_MAX);
    if (len == 0 || len > DEVICE_ID_MAX - 1) {
        return 0;  // 无效ID
    }
    return 1;  // 有效ID
}

4.4 与 strlen () 的适用场景对比

场景	推荐函数	原因
处理已知合法的字符串常量	strlen()	效率更高，无需边界检查
处理用户输入 / 网络数据	strlen_s()	需防止恶意输入导致越界
动态内存操作	strlen_s()	内存可能被篡改或分配错误
性能敏感的内部逻辑	strlen()	减少边界检查的性能开销
安全关键系统	strlen_s()	优先保证安全性，避免崩溃

五、注意事项：安全使用的关键细节

5.1 正确设置 maxsize 参数

maxsize 必须准确反映字符串所在缓冲区的大小，否则会导致两种问题：

设置过大：失去边界检查意义，可能仍发生越界
设置过小：提前终止检查，得到错误的长度值

char buf[50] = "正确设置maxsize的示例";
size_t len1 = strlen_s(buf, 50);  // 正确：maxsize=缓冲区大小
size_t len2 = strlen_s(buf, 100); // 错误：maxsize超过实际缓冲区
size_t len3 = strlen_s(buf, 10);  // 错误：maxsize过小，可能提前终止

5.2 错误处理机制

strlen_s () 返回 0 时可能有两种情况：字符串确实为空（长度 0）或发生错误，需通过 errno 区分：

#include <errno.h>

size_t len = strlen_s(str, maxsize);
if (len == 0) {
    if (errno == EINVAL) {
        printf("错误：无效参数（空指针或maxsize=0）\n");
    } else if (errno == EILSEQ) {
        printf("错误：未找到终止符\n");
    } else {
        printf("字符串为空（长度0）\n");
    }
}

5.3 编译器兼容性

并非所有编译器都默认支持 C11 的边界检查接口：

Visual Studio：完全支持，无需额外设置
GCC/Clang：需定义__STDC_WANT_LIB_EXT1__宏并启用 C11 及以上标准

#define __STDC_WANT_LIB_EXT1__ 1  // 启用边界检查接口
#include <string.h>

// GCC编译时需加：-std=c11

5.4 与 strlen () 的混用风险

当 strlen_s () 与 strlen () 混用时，需特别注意：

strlen_s () 返回 0 可能表示错误，而 strlen () 返回 0 一定是空字符串
对同一字符串，两者计算结果可能不同（当字符串无终止符时）

六、完整示例：安全字符串处理工具

以下实现一个基于 strlen_s () 的安全字符串处理工具，对比传统 strlen () 的实现：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

#define BUFFER_SIZE 50

// 基于strlen_s()的安全实现
int safe_string_processor(const char *input, size_t input_buf_size) {
    // 1. 安全计算长度
    errno = 0;  // 重置错误码
    size_t input_len = strlen_s(input, input_buf_size);
    
    // 2. 错误处理
    if (input_len == 0) {
        if (errno == EINVAL) {
            fprintf(stderr, "安全处理：无效输入参数\n");
            return -1;
        } else if (errno == EILSEQ) {
            fprintf(stderr, "安全处理：输入字符串无终止符\n");
            return -1;
        }
    }
    
    // 3. 长度验证
    if (input_len > BUFFER_SIZE - 1) {
        fprintf(stderr, "安全处理：输入过长（最大%d字符）\n", BUFFER_SIZE - 1);
        return -1;
    }
    
    // 4. 安全复制
    char output[BUFFER_SIZE];
    for (size_t i = 0; i <= input_len; i++) {
        output[i] = input[i];
    }
    
    printf("安全处理成功：%s（长度：%zu）\n", output, input_len);
    return 0;
}

// 基于strlen()的传统实现
int unsafe_string_processor(const char *input) {
    // 1. 无空指针检查（风险）
    // 2. 无边界检查（风险）
    size_t input_len = strlen(input);  // 可能越界
    
    // 3. 长度验证
    if (input_len > BUFFER_SIZE - 1) {
        fprintf(stderr, "传统处理：输入过长\n");
        return -1;
    }
    
    // 4. 复制（风险）
    char output[BUFFER_SIZE];
    for (size_t i = 0; i <= input_len; i++) {
        output[i] = input[i];
    }
    
    printf("传统处理成功：%s（长度：%zu）\n", output, input_len);
    return 0;
}

int main() {
    // 测试用例1：合法字符串
    char valid_str[] = "合法字符串";
    printf("=== 测试合法字符串 ===\n");
    safe_string_processor(valid_str, sizeof(valid_str));
    unsafe_string_processor(valid_str);
    
    // 测试用例2：无终止符的字符串
    char no_null_str[5] = {'不', '合', '法', '字', '符'};  // 无'\0'
    printf("\n=== 测试无终止符字符串 ===\n");
    safe_string_processor(no_null_str, sizeof(no_null_str));  // 安全处理
    unsafe_string_processor(no_null_str);  // 风险：越界访问
    
    // 测试用例3：空指针
    printf("\n=== 测试空指针 ===\n");
    safe_string_processor(NULL, 10);  // 安全处理
    unsafe_string_processor(NULL);    // 风险：未定义行为（可能崩溃）
    
    return 0;
}

安全版本通过 strlen_s () 和错误处理机制，有效应对无终止符字符串和空指针
传统版本使用 strlen ()，在异常情况下会出现越界访问或崩溃
实际运行时，测试用例 2 和 3 中传统版本可能表现出不可预期的行为

编译运行（GCC）：

gcc -std=c11 -o string_demo string_demo.c
./string_demo

strlen_s () 作为 C11 引入的安全函数，通过增加边界检查和错误处理，解决了 strlen () 长期存在的安全隐患。但这并非意味着 strlen () 应该被完全抛弃 —— 在已知字符串合法（如字符串常量）且性能敏感的场景，strlen () 的高效性仍具优势。

开发者应根据具体场景选择：

当处理外部输入、动态内存或安全关键代码时，优先使用 strlen_s ()
当操作内部可控的字符串且追求性能时，可继续使用 strlen ()

C 语言的发展始终在安全性与兼容性之间寻找平衡，strlen_s () 与 strlen () 的并存，正是这种平衡的体现。理解两者的差异与适用场景，才能写出既高效又安全的 C 语言代码。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-10-15，如有侵权请联系 cloudcommunity@tencent.com 删除

函数

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度