C/C++字符串比较函数strcmp的手动实现与优化

1. 项目背景与核心需求

在C/C++开发中，字符串比较是最基础却最容易被忽视的基本功。标准库提供的strcmp()函数虽然方便，但很多面试官喜欢考察候选人手写实现的能力——这不仅能检验对指针操作的理解深度，还能看出边界条件处理的严谨性。我曾在技术面试中让候选人手写strcmp，超过60%的人会在空指针或非终止字符串场景翻车。

这个项目的本质是：仅用基本指针操作，实现与标准库strcmp完全一致的字符串字典序比较功能。核心难点在于正确处理以下场景：

• 其中一个字符串提前遇到'\0'
• 两个字符串完全相等
• 传入空指针
• 字符串中包含非ASCII字符

2. 函数原型设计与原理分析

2.1 标准库行为规范

首先必须明确标准库strcmp的返回值规范：

c复制int strcmp(const char* s1, const char* s2);

• 返回0表示字符串完全一致
• 返回正数表示s1 > s2（字典序）
• 返回负数表示s1 < s2（字典序）

注意：标准并未规定返回的具体数值，只要求正负符号正确。实际实现通常返回字符差值。

2.2 指针遍历算法

手动实现的核心逻辑是：

1. 并行遍历两个字符串的每个字符
2. 遇到第一个不相同的字符时，返回它们的差值
3. 如果某个字符串先结束，则返回长度差
4. 两个字符串完全相同时返回0

关键点在于：

• 必须使用unsigned char比较，避免符号扩展问题
• 每次循环只需判断s1是否等于s2，不等时立即返回
• 循环终止条件要同时检查两个字符串是否结束

3. 基础实现代码

3.1 最小实现版本

c复制int my_strcmp(const char* s1, const char* s2) {
    while (*s1 && (*s1 == *s2)) {
        s1++;
        s2++;
    }
    return *(const unsigned char*)s1 - *(const unsigned char*)s2;
}

这个版本虽然简洁，但存在严重缺陷：

1. 没有处理空指针输入
2. 字符比较未强制转为unsigned char
3. 返回值可能因char符号性导致错误

3.2 工业级实现

c复制int my_strcmp(const char* s1, const char* s2) {
    if (!s1 || !s2) {
        // 实际项目应该用更专业的错误处理
        if (!s1 && !s2) return 0;
        return !s1 ? -1 : 1;
    }

    while (*s1 && *s2 && *s1 == *s2) {
        s1++;
        s2++;
    }

    return *(const unsigned char*)s1 - *(const unsigned char*)s2;
}

改进点：

• 增加空指针检查
• 强制unsigned char转换避免符号问题
• 对空指针输入给出确定返回值

4. 极端情况处理

4.1 非终止字符串问题

如果传入的字符串没有'\0'终止符，标准strcmp会导致内存越界。我们的实现可以增加长度限制参数：

c复制int my_strcmp_ex(const char* s1, const char* s2, size_t max_len) {
    if (!s1 || !s2) { /* 同上 */ }
    
    while (max_len-- && *s1 && *s2 && *s1 == *s2) {
        s1++;
        s2++;
    }

    if (!max_len) return 0; // 达到比较长度限制
    return *(const unsigned char*)s1 - *(const unsigned char*)s2;
}

4.2 性能优化技巧

现代CPU的流水线特性使得以下优化可能提升性能：

c复制int my_strcmp_opt(const char* s1, const char* s2) {
    // 检查前4字节对齐比较（假设32位系统）
    const uint32_t* ws1 = (const uint32_t*)s1;
    const uint32_t* ws2 = (const uint32_t*)s2;
    
    while (!(*(ws1++) - *(ws2++))) {
        // 字对齐比较
    }
    // 剩余字节处理...
}

警告：这种优化需要处理字节序问题，且可能违反严格别名规则，仅在某些特定场景适用。

5. 测试用例设计

完整的测试应该覆盖以下场景：

实测代码：

c复制void test_my_strcmp() {
    assert(my_strcmp(NULL, NULL) == 0);
    assert(my_strcmp(NULL, "") < 0);
    assert(my_strcmp("", NULL) > 0);
    assert(my_strcmp("", "") == 0);
    assert(my_strcmp("a", "b") < 0);
    assert(my_strcmp("b", "a") > 0);
    assert(my_strcmp("abc", "abc") == 0);
    assert(my_strcmp("abc", "abcd") < 0);
    assert(my_strcmp("abcd", "abc") > 0);
    assert(my_strcmp("\xff", "\x7f") > 0);
}

6. 常见实现误区

6.1 符号扩展问题

错误实现：

c复制// 错误！char可能是有符号的
return *s1 - *s2;

当字符值大于127时，符号扩展会导致错误结果。必须强制转换为unsigned char。

6.2 冗余判断

低效实现：

c复制while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)

简化为：

c复制while (*s1 && *s2 && *s1 == *s2)

因为'\0'的ASCII值为0，在布尔判断中等效。

6.3 返回值不规范

不规范的实现可能返回任意正负数，而标准库通常返回字符实际差值。例如比较'a'和'c'应该返回-2而非简单的-1。

7. 扩展应用场景

7.1 自定义比较规则

通过传入比较函数指针，可以实现：

c复制int strcmp_ex(const char* s1, const char* s2, 
              int (*cmp)(char, char)) {
    while (*s1 && *s2 && cmp(*s1, *s2) == 0) {
        s1++;
        s2++;
    }
    return cmp(*s1, *s2);
}

7.2 大小写不敏感比较

c复制int case_insensitive_cmp(char a, char b) {
    return tolower((unsigned char)a) - tolower((unsigned char)b);
}

int strcasecmp(const char* s1, const char* s2) {
    return strcmp_ex(s1, s2, case_insensitive_cmp);
}

8. 性能对比测试

在x86-64平台实测（比较1MB随机字符串）：

实际项目中99%的情况应该直接使用标准库实现，它们通常使用了处理器特定的SIMD指令优化（如SSE4.2的pcmpistri指令）

9. 移植性考虑

不同平台的注意事项：

1. 字符集问题：EBCDIC编码中字母不连续，字典序与ASCII不同
2. 字节序问题：字对齐优化需要考虑CPU的endianness
3. 内存模型：某些嵌入式平台可能限制指针运算
4. 信号安全：标准库实现通常是async-signal-safe的

一个可移植的改进版本：

c复制int portable_strcmp(const char* s1, const char* s2) {
    if (!s1 || !s2) { /* 同上 */ }
    
    unsigned char c1, c2;
    do {
        c1 = (unsigned char)*s1++;
        c2 = (unsigned char)*s2++;
    } while (c1 && c1 == c2);

    return c1 - c2;
}

10. 相关面试题扩展

类似的基础函数实现问题还包括：

1. 实现memcpy（考虑内存重叠问题）
2. 实现atoi（处理溢出和非法输入）
3. 实现strstr（子串查找算法）
4. 实现内存池分配器

以memcpy为例，正确处理内存重叠的写法：

c复制void* my_memcpy(void* dest, const void* src, size_t n) {
    char* d = dest;
    const char* s = src;
    
    if (d < s) {
        while (n--) *d++ = *s++;
    } else {
        char* lastd = d + n - 1;
        const char* lasts = s + n - 1;
        while (n--) *lastd-- = *lasts--;
    }
    
    return dest;
}

在实现这些基础函数时，最关键的不仅是功能正确，更要考虑：

• 边界条件处理
• 性能与安全的权衡
• 可移植性要求
• 与标准库行为的一致性