字符串长度计算函数strlen()详解

byte轻骑兵

发布于 2026-01-20 17:08:04

1600

在 C 语言编程中，字符串操作是核心场景之一，而 strlen() 作为字符串处理的 “基石函数”，几乎出现在所有涉及字符串长度计算的代码中。尽管它的功能看似简单 —— 计算字符串的有效长度，但在实际使用中，因对其底层原理、返回值特性及边界条件理解不足，很容易引发内存越界、逻辑错误等问题。

一、函数简介

strlen() 是 C 标准库（string.h 头文件）提供的字符串处理函数，其核心功能是计算字符串中从起始地址到第一个空字符（'\0'）的字节数，返回值为无符号整数类型 size_t。注意：这里的 “长度” 不包含作为字符串结束标志的 '\0'。

举个直观例子：

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

int main() {
    char str[] = "Hello World";  // 字符串常量末尾隐含 '\0'
    printf("字符串内容：%s\n", str);
    printf("strlen() 计算结果：%zu\n", strlen(str));  // 输出 11
    printf("sizeof 计算结果：%zu\n", sizeof(str));    // 输出 12（包含 '\0'）
    return 0;
}

"Hello World" 实际在内存中存储为 H e l l o W o r l d \0（共 12 个字节），strlen() 从首地址开始遍历，遇到 '\0' 停止，因此返回 11；而 sizeof 计算的是整个数组的字节大小，包含 '\0'，所以返回 12。

这里需要明确 strlen() 的两个核心特性：

依赖 '\0' 终止：若字符串未以 '\0' 结尾，strlen() 会继续向后遍历内存，直到找到 '\0'，导致结果不可控（可能越界访问非法内存）。
返回无符号值：返回类型 size_t 本质是 unsigned int 或 unsigned long（取决于平台），意味着它无法表示负数，使用时需避免 “无符号减法” 的逻辑陷阱。

二、函数原型

strlen() 的标准原型定义在 string.h 中，格式如下：

size_t strlen(const char *str);

我们逐部分拆解这个原型，理解其设计逻辑：

1. 参数 const char *str：

char *str：表示指向字符串首地址的指针，strlen() 通过该指针遍历字符串内容。
const 修饰：表明函数内部不会修改 str 指向的字符串内容，这是一种 “只读保护”—— 既避免函数误修改输入字符串，也允许传入字符串常量（如 "abc"），符合 C 语言的 “const 正确性” 设计原则。
特殊情况：若传入 NULL（空指针），strlen() 会触发未定义行为（UB），因为空指针指向无效内存，无法进行解引用操作（*str）。

2. 返回值 size_t：

size_t 是 C 标准定义的无符号整数类型（在 <stddef.h> 中声明），通常对应平台的 “自然字长”——32 位系统中为 unsigned int（4 字节），64 位系统中为 unsigned long（8 字节）。
设计为无符号的原因：字符串长度不可能为负数，用 size_t 能充分利用整数范围（如 32 位 size_t 最大可表示 4GB 长度的字符串），同时与 sizeof 运算符的返回值类型保持一致，方便联合使用（如动态内存分配时计算长度）。

三、函数实现（伪代码）

strlen() 的核心逻辑是 “遍历字符串直到 '\0'，统计字节数”，标准库中的实现会结合平台特性做优化（如利用 CPU 指令一次处理多字节），但核心原理可通过朴素伪代码理解。

3.1 朴素实现（逐字节遍历）

最直观的实现方式是从字符串首地址开始，逐字节判断是否为 '\0'，同时计数：

// 自定义 strlen() 伪代码（朴素版）
size_t my_strlen(const char *str) {
    // 第一步：检查空指针（标准库未定义空指针处理，此处为安全增强）
    if (str == NULL) {
        fprintf(stderr, "错误：传入了空指针\n");
        return 0;  // 实际标准库可能直接崩溃，此处返回 0 仅为演示
    }

    const char *ptr = str;  // 用临时指针遍历，避免修改原指针
    size_t count = 0;       // 计数变量，初始为 0

    // 遍历直到遇到 '\0'（注意：不统计 '\0'）
    while (*ptr != '\0') {
        count++;    // 计数+1
        ptr++;      // 指针向后移动 1 字节（char 占 1 字节）
    }

    return count;  // 返回最终计数
}

3.2 优化实现（指针减法）

上述朴素版用了 count 变量，实际上可通过 “指针减法” 简化 —— 因为 str 指向字符串首地址，ptr 最终指向 '\0'，两者差值即为字节数（char 类型占 1 字节，指针差值 = 元素个数）：

// 自定义 strlen() 伪代码（优化版：指针减法）
size_t my_strlen(const char *str) {
    if (str == NULL) {
        fprintf(stderr, "错误：传入了空指针\n");
        return 0;
    }

    const char *ptr = str;
    // 直接移动指针到 '\0' 位置，不单独计数
    while (*ptr != '\0') {
        ptr++;
    }

    // 指针差值 = 首地址到 '\0' 的字节数（即字符串长度）
    return ptr - str;
}

3.3 标准库优化（多字节并行处理）

实际标准库（如 GNU C 库、MSVC 库）的 strlen() 会针对 CPU 架构做优化，例如：

64 位平台：利用 mmx 或 sse 指令，一次读取 8 字节（64 位）数据，通过位运算判断是否包含 '\0'，大幅减少循环次数（如 1000 字节的字符串，仅需循环 125 次，而非 1000 次）。
边界对齐：先处理非对齐的前几个字节，再按 “字长”（4/8 字节）批量处理，减少内存访问开销。

以 GNU C 库的 strlen() 简化逻辑为例（伪代码）：

// GNU C 库 strlen() 核心逻辑简化（64 位平台）
size_t strlen(const char *str) {
    if (str == NULL) return 0;

    const unsigned long *ptr = (const unsigned long *)str;
    const unsigned long zero = 0;  // 用于判断 '\0' 的掩码

    // 1. 处理前几个非对齐字节（确保指针按 8 字节对齐）
    while ((unsigned long)ptr % 8 != 0) {
        if (*(const char *)ptr == '\0') {
            return (const char *)ptr - str;
        }
        ptr++;
    }

    // 2. 批量处理 8 字节数据（一次判断 8 个字符是否有 '\0'）
    while (1) {
        // 位运算判断 8 字节中是否包含 '\0'（原理：若某字节为 0，对应位会被检测到）
        if (((*ptr - 0x0101010101010101UL) & ~*ptr & 0x8080808080808080UL) != 0) {
            // 若包含 '\0'，再逐字节定位具体位置
            const char *char_ptr = (const char *)ptr;
            if (char_ptr[0] == '\0') return char_ptr - str;
            if (char_ptr[1] == '\0') return char_ptr + 1 - str;
            if (char_ptr[2] == '\0') return char_ptr + 2 - str;
            // ... 省略中间 3-6 字节判断 ...
            if (char_ptr[7] == '\0') return char_ptr + 7 - str;
        }
        ptr++;  // 8 字节处理完，指针后移
    }
}

这种优化虽复杂，但核心逻辑仍未脱离 “找 '\0' 计数” 的本质，只是通过硬件特性提升了效率。

四、使用场景：strlen () 能解决什么问题？

strlen() 是字符串处理的 “基础设施”，几乎所有涉及字符串长度的场景都需要它，以下是 4 个典型使用场景：

4.1 字符串长度验证（输入合法性检查）

在处理用户输入或外部数据时，常需验证字符串长度是否符合要求（如用户名、密码长度限制）：

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

#define USERNAME_MAX 20  // 用户名最大长度（不含 '\0'）
#define PASSWORD_MIN 6   // 密码最小长度

// 验证用户名合法性
int check_username(const char *username) {
    if (username == NULL) return 0;  // 空指针无效
    size_t len = strlen(username);
    return (len >= 1 && len <= USERNAME_MAX) ? 1 : 0;  // 长度 1~20 合法
}

// 验证密码合法性
int check_password(const char *password) {
    if (password == NULL) return 0;
    return (strlen(password) >= PASSWORD_MIN) ? 1 : 0;  // 长度 ≥6 合法
}

int main() {
    char username[USERNAME_MAX + 1];  // +1 存 '\0'
    char password[50];

    printf("请输入用户名（1-20 个字符）：");
    scanf("%s", username);
    printf("请输入密码（≥6 个字符）：");
    scanf("%s", password);

    if (check_username(username)) {
        printf("用户名合法\n");
    } else {
        printf("用户名非法（长度需 1-20 个字符）\n");
    }

    if (check_password(password)) {
        printf("密码合法\n");
    } else {
        printf("密码非法（长度需 ≥6 个字符）\n");
    }

    return 0;
}

4.2 动态内存分配（按需分配空间）

在复制字符串（如 strcpy）或拼接字符串（如 strcat）时，需先用 strlen() 计算源字符串长度，再按需分配内存（避免内存浪费或不足）：

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

// 自定义字符串复制函数（安全版，需手动分配内存）
char *safe_strcpy(const char *src) {
    if (src == NULL) return NULL;

    // 1. 计算源字符串长度，分配内存（+1 存 '\0'）
    size_t src_len = strlen(src);
    char *dest = (char *)malloc(src_len + 1);  // 关键：+1 不可少
    if (dest == NULL) {  // 检查内存分配是否成功
        perror("malloc 失败");
        return NULL;
    }

    // 2. 复制字符串（包括 '\0'）
    for (size_t i = 0; i <= src_len; i++) {  // i <= src_len 确保复制 '\0'
        dest[i] = src[i];
    }

    return dest;
}

int main() {
    const char *src = "动态内存分配需要 strlen() 计算长度！";
    char *dest = safe_strcpy(src);

    if (dest != NULL) {
        printf("源字符串：%s（长度：%zu）\n", src, strlen(src));
        printf("复制后：%s（长度：%zu）\n", dest, strlen(dest));
        free(dest);  // 释放内存，避免泄漏
        dest = NULL; // 避免野指针
    }

    return 0;
}

这里的关键是 malloc(src_len + 1)—— 若忘记 +1，则无法存储 '\0'，后续调用 strlen(dest) 会越界访问，导致结果不可控。

4.3 字符串截断与拼接（控制长度）

当需要截断过长的字符串，或拼接字符串前判断总长度是否超过缓冲区大小时，strlen() 是核心工具：

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

#define BUF_SIZE 50  // 缓冲区最大容量（含 '\0'）

// 截断字符串到指定长度（并确保以 '\0' 结尾）
void truncate_str(char *str, size_t max_len) {
    if (str == NULL || max_len == 0) return;

    size_t len = strlen(str);
    if (len > max_len) {
        str[max_len] = '\0';  // 截断：在 max_len 位置设 '\0'
    }
}

// 安全拼接字符串（避免缓冲区溢出）
int safe_strcat(char *dest, const char *src, size_t dest_buf_size) {
    if (dest == NULL || src == NULL) return 0;

    size_t dest_len = strlen(dest);
    size_t src_len = strlen(src);

    // 检查拼接后总长度是否超过缓冲区（dest_len + src_len + 1 ≤ dest_buf_size）
    if (dest_len + src_len + 1 > dest_buf_size) {
        fprintf(stderr, "拼接失败：缓冲区不足（需 %zu 字节，仅 %zu 字节）\n",
                dest_len + src_len + 1, dest_buf_size);
        return 0;
    }

    // 拼接字符串（从 dest 末尾开始复制 src）
    for (size_t i = 0; i <= src_len; i++) {
        dest[dest_len + i] = src[i];
    }
    return 1;
}

int main() {
    char buf[BUF_SIZE] = "Hello, ";  // 初始字符串
    const char *append = "this is a long string to test truncate and concat!";

    // 1. 先尝试拼接，若缓冲区不足则截断 src 后再拼接
    if (!safe_strcat(buf, append, BUF_SIZE)) {
        printf("尝试截断后拼接...\n");
        // 计算可拼接的最大长度：缓冲区剩余空间 - 1（存 '\0'）
        size_t available = BUF_SIZE - strlen(buf) - 1;
        char truncated_src[available + 1];
        strncpy(truncated_src, append, available);  // 复制 available 个字符
        truncated_src[available] = '\0';            // 手动加 '\0'（strncpy 不保证）
        safe_strcat(buf, truncated_src, BUF_SIZE);  // 再次拼接
    }

    printf("最终字符串：%s\n", buf);
    printf("最终长度：%zu\n", strlen(buf));
    return 0;
}

4.4 格式化输出控制（按长度显示）

在日志输出或界面展示时，若字符串过长，可通过 strlen() 判断是否需要换行或省略显示：

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

#define LOG_MAX_LEN 30  // 日志单行最大显示长度

// 按长度控制日志输出（过长则换行）
void log_with_wrap(const char *msg) {
    if (msg == NULL) return;

    size_t len = strlen(msg);
    size_t start = 0;

    // 若长度超过 LOG_MAX_LEN，分多行输出
    while (start < len) {
        size_t end = start + LOG_MAX_LEN;
        if (end > len) end = len;  // 最后一行不足 LOG_MAX_LEN，取实际长度

        // 输出当前片段（从 start 到 end-1）
        for (size_t i = start; i < end; i++) {
            putchar(msg[i]);
        }
        putchar('\n');  // 换行

        start = end;  // 下一段起始位置
    }
}

int main() {
    const char *long_log = "2024-05-20 14:30:00 [INFO] 用户[12345]执行了[订单提交]操作，订单ID：89756，商品列表：[手机x1, 耳机x1]，支付金额：5999.00元";
    printf("带换行的日志输出：\n");
    log_with_wrap(long_log);
    return 0;
}

五、注意事项

strlen() 的使用错误是 C 语言新手的高频问题，核心原因是对其 “依赖 '\0'” 和 “无符号返回值” 的特性理解不足。以下是 5 个必须注意的坑：

5.1 坑 1：传入空指针（NULL）

若向 strlen() 传入 NULL，函数会尝试解引用空指针（*str），触发未定义行为—— 可能直接崩溃（如 Windows 下弹出 “程序已停止工作”），也可能返回随机值，完全不可控。

错误示例：

#include <string.h>

int main() {
    char *str = NULL;
    size_t len = strlen(str);  // 未定义行为！可能崩溃
    printf("长度：%zu\n", len);
    return 0;
}

正确做法：使用前先检查指针是否为 NULL：

size_t safe_strlen(const char *str) {
    return (str == NULL) ? 0 : strlen(str);  // 空指针返回 0（自定义规则）
}

5.2 坑 2：无符号返回值的减法陷阱

size_t 是无符号类型，若用 strlen(a) - strlen(b) 比较长度，当 a 比 b 短时，结果会是一个极大的正数（而非负数），导致逻辑错误。

错误示例：

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

int main() {
    const char *a = "short";  // strlen(a) = 5
    const char *b = "longer"; // strlen(b) = 6

    // 预期：a 比 b 短，输出 "a is shorter"
    if (strlen(a) - strlen(b) > 0) {  // 5 - 6 = 4294967295（32位 size_t）
        printf("a is longer\n");      // 错误输出！
    } else {
        printf("a is shorter\n");
    }

    return 0;
}

正确做法：直接用比较运算符（>/<），而非减法：

if (strlen(a) > strlen(b)) {  // 直接比较，无符号特性不影响
    printf("a is longer\n");
} else {
    printf("a is shorter\n");  // 正确输出
}

5.3 坑 3：字符串未以 '\0' 结尾

strlen() 依赖 '\0' 终止，若字符串是手动初始化的字符数组且未加 '\0'，函数会越界访问内存，直到找到随机的 '\0'，返回错误长度。

错误示例：

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

int main() {
    // 错误：字符数组未以 '\0' 结尾，不是合法字符串
    char str[3] = {'H', 'i'};  // 内存中：H i [随机值] ...
    size_t len = strlen(str);  // 越界访问，返回随机值（如 5、10 等）
    printf("长度：%zu\n", len);  // 结果不可控
    return 0;
}

正确做法：确保字符串以 '\0' 结尾：

// 方法 1：手动加 '\0'
char str1[3] = {'H', 'i', '\0'};
// 方法 2：用字符串常量初始化（自动加 '\0'）
char str2[] = "Hi";
// 方法 3：初始化时留空，编译器自动补 '\0'
char str3[10] = "Hi";  // 剩余 8 字节填充 0（即 '\0'）

5.4 坑 4：混淆 strlen () 与 sizeof

strlen() 计算的是 “有效字符串长度（不含 '\0'）”，而 sizeof 计算的是 “变量 / 类型的字节大小”，两者针对字符串数组的结果差异巨大，极易混淆。

对比示例：

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

int main() {
    // 场景 1：字符串数组（自动加 '\0'）
    char str1[] = "abc";
    printf("str1: strlen=%zu, sizeof=%zu\n", strlen(str1), sizeof(str1));  // 3, 4

    // 场景 2：指定大小的数组（未填满，剩余空间补 0）
    char str2[10] = "abc";
    printf("str2: strlen=%zu, sizeof=%zu\n", strlen(str2), sizeof(str2));  // 3, 10

    // 场景 3：字符指针（指向字符串常量）
    char *str3 = "abc";
    printf("str3: strlen=%zu, sizeof=%zu\n", strlen(str3), sizeof(str3));  // 3, 8（64位指针）

    // 场景 4：未终止的字符数组
    char str4[3] = {'a', 'b', 'c'};
    printf("str4: strlen=%zu, sizeof=%zu\n", strlen(str4), sizeof(str4));  // 随机值, 3

    return 0;
}

核心区别总结：

特性	strlen()	sizeof
功能	计算字符串有效长度（到 '\0'）	计算变量 / 类型的字节大小
处理对象	仅字符串（需 '\0' 终止）	任意变量 / 类型（数组、指针、结构体等）
运行时 / 编译时	运行时计算（遍历内存）	编译时计算（仅依赖类型信息）
对指针的处理	解引用指针，遍历字符串	计算指针本身的字节大小（4/8 字节）

5.5 坑 5：用于宽字符字符串（wchar_t）

strlen() 是为单字节字符（char）设计的，若用于宽字符字符串（wchar_t，每个字符占 2/4 字节），会因 “按字节判断 '\0'” 导致错误。

错误示例：

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

int main() {
    wchar_t wstr[] = L"宽字符";  // L 表示宽字符常量，每个字符占 2 字节
    // 错误：strlen() 按字节遍历，会把宽字符的低字节 0 误判为 '\0'
    size_t len = strlen((const char *)wstr);  // 结果可能为 1（而非 2）
    printf("错误长度：%zu\n", len);

    // 正确：用宽字符专用函数 wcslen()
    size_t wlen = wcslen(wstr);
    printf("正确长度：%zu\n", wlen);  // 输出 2
    return 0;
}

正确做法：宽字符字符串用 wcslen()（定义在 <wchar.h> 中），其逻辑与 strlen() 一致，但按宽字符（wchar_t）遍历，判断 L'\0' 终止。

六、完整示例代码：综合实战

下面通过一个 “字符串处理工具” 的综合示例，串联 strlen() 的核心用法，涵盖动态内存分配、长度验证、安全复制等场景：

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

// 常量定义
#define MAX_INPUT_LEN 100    // 输入字符串最大长度
#define MAX_RESULT_LEN 200   // 结果字符串最大长度

// 安全计算字符串长度（处理空指针）
static size_t safe_strlen(const char *str) {
    return (str == NULL) ? 0 : strlen(str);
}

// 验证字符串长度是否在 [min_len, max_len] 范围内
static bool validate_str_len(const char *str, size_t min_len, size_t max_len) {
    if (str == NULL) return false;
    size_t len = safe_strlen(str);
    return (len >= min_len && len <= max_len);
}

// 安全复制字符串（动态分配内存，自动处理 '\0'）
static char *safe_strdup(const char *src) {
    if (src == NULL) return NULL;

    size_t src_len = safe_strlen(src);
    // 分配内存：src_len + 1（存 '\0'）
    char *dest = (char *)malloc(src_len + 1);
    if (dest == NULL) {
        perror("malloc 失败");
        return NULL;
    }

    // 复制字符串（包括 '\0'）
    for (size_t i = 0; i <= src_len; i++) {
        dest[i] = src[i];
    }

    return dest;
}

// 安全拼接两个字符串（结果存入动态内存，避免溢出）
static char *safe_strjoin(const char *str1, const char *str2) {
    if (str1 == NULL && str2 == NULL) return NULL;

    size_t len1 = safe_strlen(str1);
    size_t len2 = safe_strlen(str2);
    size_t total_len = len1 + len2;

    // 分配总长度 + 1（存 '\0'）
    char *result = (char *)malloc(total_len + 1);
    if (result == NULL) {
        perror("malloc 失败");
        return NULL;
    }

    // 复制第一个字符串
    for (size_t i = 0; i < len1; i++) {
        result[i] = str1[i];
    }
    // 复制第二个字符串（接在第一个后面）
    for (size_t i = 0; i <= len2; i++) {  // 包含 '\0'
        result[len1 + i] = str2[i];
    }

    return result;
}

int main() {
    char input1[MAX_INPUT_LEN + 1];
    char input2[MAX_INPUT_LEN + 1];

    // 1. 读取用户输入
    printf("请输入第一个字符串（1-%d 个字符）：", MAX_INPUT_LEN);
    scanf("%s", input1);
    printf("请输入第二个字符串（1-%d 个字符）：", MAX_INPUT_LEN);
    scanf("%s", input2);

    // 2. 验证输入长度
    if (!validate_str_len(input1, 1, MAX_INPUT_LEN)) {
        fprintf(stderr, "第一个字符串长度非法！\n");
        return 1;
    }
    if (!validate_str_len(input2, 1, MAX_INPUT_LEN)) {
        fprintf(stderr, "第二个字符串长度非法！\n");
        return 1;
    }

    // 3. 安全复制字符串
    char *copy1 = safe_strdup(input1);
    char *copy2 = safe_strdup(input2);
    if (copy1 == NULL || copy2 == NULL) {
        fprintf(stderr, "字符串复制失败！\n");
        free(copy1);  // 避免内存泄漏
        free(copy2);
        return 1;
    }

    // 4. 安全拼接字符串
    char *joined = safe_strjoin(copy1, copy2);
    if (joined == NULL) {
        fprintf(stderr, "字符串拼接失败！\n");
        free(copy1);
        free(copy2);
        return 1;
    }

    // 5. 输出结果
    printf("\n=== 处理结果 ===\n");
    printf("第一个字符串：%s（长度：%zu）\n", copy1, safe_strlen(copy1));
    printf("第二个字符串：%s（长度：%zu）\n", copy2, safe_strlen(copy2));
    printf("拼接后字符串：%s（长度：%zu）\n", joined, safe_strlen(joined));

    // 6. 释放动态内存（避免泄漏）
    free(copy1);
    free(copy2);
    free(joined);
    copy1 = copy2 = joined = NULL;  // 避免野指针

    return 0;
}