字符串处理优化：别让字符串拖垮你的性能
字符串操作，看起来简单，对吧？
但说实话，我在嵌入式项目里见过太多因为字符串处理不当导致的性能灾难。有一次，一个数据采集模块每秒要处理上千条日志，结果就因为几处 strlen 的重复调用，CPU 占用直接飙到 70%。我当时一看代码就明白了——嗯，又是老问题。
今天咱们就聊聊字符串处理里最常见的三个坑：重复调用 strlen、用 strcpy 而不是 memcpy、以及字符串拼接的陷阱。这些坑，我几乎在每个项目里都见过。
核心观点：字符串操作是 C 语言性能优化的「隐形杀手」。一个不经意的 strlen 调用，可能让你的 O(n) 算法变成 O(n²)。
1. 避免 strlen 重复调用
先看一个我经常遇到的代码片段：
// 糟糕的写法
for (int i = 0; i < strlen(str); i++) {
// 处理每个字符
}这段代码有什么问题？
每次循环都要调用 strlen(str)。而 strlen 本身是 O(n) 的——它要从头遍历到结尾找 '\0'。如果字符串长度是 1000，循环 1000 次，那 strlen 就被调用了 1000 次，每次遍历 1000 个字符。总复杂度是多少？O(n²)。
你想想看，一个简单的循环，因为一个 strlen，性能直接降了一个数量级。
正确的做法是什么？提前把长度算好：
// 优化的写法
size_t len = strlen(str);
for (size_t i = 0; i < len; i++) {
// 处理每个字符
}就这么简单的一改，O(n²) 变 O(n)。
我的习惯：只要字符串长度在循环中不变，我一定在循环外先算好。这个习惯帮我避免了很多性能问题。
还有一种情况更隐蔽——在条件判断里重复调用 strlen：
// 糟糕的写法
if (strlen(str) > 0 && str[0] == 'A') { ... }
// 优化的写法
size_t len = strlen(str);
if (len > 0 && str[0] == 'A') { ... }虽然这里只调用两次，但如果在热路径上，累积起来也很可观。
2. 使用 memcpy 替代 strcpy
很多人习惯用 strcpy 复制字符串。但 strcpy 有个问题——它每次复制一个字节，然后检查是否遇到 '\0'。说白了，它是个逐字节的、带条件判断的复制操作。
而 memcpy 呢？它按字（word）复制，一次复制 4 个或 8 个字节，没有条件判断。在大多数架构上，memcpy 比 strcpy 快 2-5 倍。
看个例子：
// 慢的写法
char dest[100];
strcpy(dest, src);
// 快的写法
char dest[100];
size_t len = strlen(src) + 1; // +1 包含 '\0'
memcpy(dest, src, len);这里要注意：memcpy 需要你明确指定长度。如果你不知道源字符串的长度，还是得先调一次 strlen。但即便如此，strlen + memcpy 通常也比 strcpy 快，因为 strlen 本身也是经过优化的（比如按字扫描）。
我曾经踩过的坑：有一次我用 memcpy 复制字符串，忘了加 +1 来包含 '\0'。结果目标缓冲区没有终止符，后续操作全部越界。记住：strlen 返回的是字符个数，不包括 '\0'，所以复制时要 +1。
另外，如果你确定源字符串长度已知（比如从配置表里读出来的固定字符串），直接用 memcpy 连 strlen 都省了：
#define MAX_NAME_LEN 32
char name[MAX_NAME_LEN] = "sensor_01";
char buffer[MAX_NAME_LEN];
memcpy(buffer, name, MAX_NAME_LEN); // 长度已知，无需 strlen3. 字符串拼接的陷阱
字符串拼接，最常见的写法是用 strcat。但 strcat 的性能问题非常严重。
为什么？因为 strcat 每次都要先找到目标字符串的末尾（遍历一次），然后再复制。如果你连续拼接多个字符串，每次拼接都要从头遍历一次。复杂度是多少？
假设你要拼接 n 个字符串，每个长度 m。第一次拼接遍历 m，第二次遍历 2m，第三次遍历 3m……总遍历次数是 O(n²m)。
看个实际例子：
// 糟糕的写法
char buf[1024] = "";
strcat(buf, "prefix_");
strcat(buf, "middle_");
strcat(buf, "suffix_");这段代码，每次 strcat 都要从 buf 开头遍历到末尾。三次拼接，遍历了 0 + 7 + 14 = 21 个字符。如果拼接 100 次呢？那就是 0 + 7 + 14 + ... + 700 ≈ 35000 次遍历。
正确的做法是手动维护一个指针，记录当前写入位置：
// 优化的写法
char buf[1024];
char *p = buf;
p += sprintf(p, "%s", "prefix_");
p += sprintf(p, "%s", "middle_");
p += sprintf(p, "%s", "suffix_");或者更直接一点，用 memcpy 加偏移：
char buf[1024];
size_t offset = 0;
memcpy(buf + offset, "prefix_", 7); offset += 7;
memcpy(buf + offset, "middle_", 7); offset += 7;
memcpy(buf + offset, "suffix_", 7); offset += 7;
buf[offset] = '\0'; // 别忘了终止符这两种方式，每次拼接都只操作目标位置，不需要遍历。复杂度是 O(n)，而不是 O(n²)。
我个人的建议：在嵌入式系统里，我几乎不用 strcat。要么用 sprintf 加指针偏移，要么用 memcpy 手动管理。虽然代码多写几行，但性能提升是实打实的。
知识体系总览
下面这张图总结了本章的核心逻辑：
性能对比一览
为了让你更直观地感受差异，我整理了一个简单的对比表：
| 操作 | 糟糕写法 | 优化写法 | 性能提升 |
|---|---|---|---|
| 循环遍历 | for(i=0; i<strlen(s); i++) | len=strlen(s); for(i=0; i<len; i++) | O(n²) → O(n) |
| 字符串复制 | strcpy(dest, src) | memcpy(dest, src, len+1) | 快 2-5 倍 |
| 字符串拼接 | strcat(buf, s) | 指针偏移 + memcpy | O(n²) → O(n) |
重要提醒：使用 memcpy 时，一定要确保目标缓冲区足够大。我曾经见过一个同事，用 memcpy 复制字符串时没检查长度，结果缓冲区溢出，导致系统随机崩溃。排查了两天才找到原因。
好了，关于字符串处理的三个优化点，今天就聊到这儿。记住：减少遍历、按块复制、手动管理偏移——这三个原则能帮你避开 90% 的字符串性能陷阱。
公众号:蓝海资料掘金营，微信deep3321