C 语言【进阶篇】之字符串 —— 轻松搞定复杂字符串操作

本文链接：https://blog.csdn.net/2402_88461821/article/details/145947995

🚀前言
🖊️初识字符与字符串
⚙️字符处理：分类与转换
- 💯字符分类函数（ctype.h）
- 💯字符转换函数
✍️字符串基础操作：长度、拷贝、拼接、比较
💻限定长度的字符串函数
🦜字符串搜索、分割与错误处理
🤔常见问题与解决方案
🐍从零实现一个字符串工具库
- 💯需求分析
- 💯代码实现
🌟总结与延伸学习

🚀前言

大家好！我是 EnigmaCoder。本文收录于我的专栏 C，感谢您的支持！

在 C 语言的编程世界里，字符串处理就像一把万能钥匙，无论是开发操作系统、数据库，还是构建高效的算法，都离不开它。对于初涉编程的新手而言，或许只将字符串当作普通的字符序列，用简单的方式进行处理。但随着学习的深入和项目需求的增长，你会发现字符串操作中隐藏着诸多技巧与挑战。比如，如何避免常见的缓冲区溢出问题，怎样高效地实现字符串的搜索与分割，这些都是进阶编程必须掌握的技能。
本文将带你深入探索 C 语言字符串的底层原理，从基础函数的深度剖析，到安全操作的实践技巧，再到复杂应用场景下的问题解决，助你从字符串处理的新手蜕变成为游刃有余的编程高手，开启高效编程的大门。

🖊️初识字符与字符串

💯字符（char）是什么？

在C语言中，char类型用于表示字符。计算机底层以数字形式存储和处理数据，ASCII码表规定了字符与数字的对应关系。比如大写字母'A'对应的ASCII码值是65，小写字母'a'对应的是97。除了普通字母和数字，还有一些特殊字符。其中，\0作为字符串终止符，它标志着一个字符串的结束；\n用于换行，在输出时会使光标移到下一行的开头；\t是制表符，用于在输出时产生一定的空白间隔，通常用于对齐文本。

💯字符串（String）的本质

从本质上讲，C语言中的字符串就是字符数组。例如char str[] = "Hello";，这里定义了一个字符数组str，并初始化为字符串"Hello"。字符串在内存中以\0结尾的字符序列形式存储。在计算字符串长度时，需要注意不包含\0本身。例如，字符串"Hi"，实际占用3个字符的存储空间，因为除了'H'和'i'，还有末尾的\0。而数组容量则是定义数组时分配的内存大小，例如char str[10] = "Hi";，数组容量是10，但实际存储的字符串长度只有3。

💯为什么需要字符串函数？

如果手动操作字符数组来处理字符串，比如实现字符串的拷贝、拼接、比较等功能，代码会非常冗长且容易出错。而C标准库提供的字符串函数，不仅安全可靠，而且高效，能大大简化代码编写过程，提高编程效率。

⚙️字符处理：分类与转换

💯字符分类函数（ctype.h）

C语言的<ctype.h>头文件提供了一系列用于字符分类的函数。常用的函数有：

函数	功能
`isdigit`	判断是否为数字字符
`isalpha`	判断是否为字母
`isspace`	判断是否为空白字符

下面是一个实战示例，统计字符串中字母、数字、空格的数量：

#include <stdio.h>
#include <ctype.h>

int main() {
    char str[] = "Hello 123 World!";
    int letterCount = 0, digitCount = 0, spaceCount = 0;
    for (int i = 0; str[i]!= '\0'; i++) {
        if (isalpha(str[i])) {
            letterCount++;
        } else if (isdigit(str[i])) {
            digitCount++;
        } else if (isspace(str[i])) {
            spaceCount++;
        }
    }
    printf("字母数量: %d\n", letterCount);
    printf("数字数量: %d\n", digitCount);
    printf("空格数量: %d\n", spaceCount);
    return 0;
}

💯字符转换函数

<ctype.h>头文件还提供了字符转换函数，toupper(c)用于将小写字母转换为大写字母，例如'a'会被转换为'A'；tolower(c)则将大写字母转换为小写字母，如'Z'会变成'z'。下面进行一个对比实验，展示手动用ASCII码转换和使用函数转换的差异：

#include <stdio.h>
#include <ctype.h>

int main() {
    char c = 'a';
    // 手动用ASCII码转换
    char manualUpper = c - 32;
    // 使用函数转换
    char funcUpper = toupper(c);
    printf("手动转换: %c\n", manualUpper);
    printf("函数转换: %c\n", funcUpper);
    return 0;
}

可以看到，使用函数转换更加简洁和直观，并且代码的可读性更高。

✍️字符串基础操作：长度、拷贝、拼接、比较

💯strlen：计算字符串长度

strlen函数用于计算字符串的长度，其核心规则是统计\0前的字符个数。例如：

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

int main() {
    char str[] = "Hello";
    size_t len = strlen(str);
    printf("字符串长度: %zu\n", len);
    return 0;
}

需要注意的是，strlen的返回值类型是size_t，它是无符号类型。在进行比较时，如果不注意，可能会出现错误。比如strlen(str1) - strlen(str2) > 0，当strlen(str1)小于strlen(str2)时，由于无符号数的特性，结果可能不是预期的。

下面是strlen的几种模拟实现方式：

计数器法：

size_t myStrlen(const char* str) {
    size_t count = 0;
    while (*str!= '\0') {
        count++;
        str++;
    }
    return count;
}

递归法：

size_t myStrlenRecursive(const char* str) {
    if (*str == '\0') {
        return 0;
    }
    return 1 + myStrlenRecursive(str + 1);
}

指针差值法：

size_t myStrlenPointer(const char* str) {
    const char* start = str;
    while (*str!= '\0') {
        str++;
    }
    return str - start;
}

💯strcpy：字符串拷贝

strcpy函数的功能是将源字符串（包括\0）复制到目标空间。例如：

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

int main() {
    char src[] = "Hello";
    char dest[10];
    strcpy(dest, src);
    printf("目标字符串: %s\n", dest);
    return 0;
}

使用strcpy时需要注意：目标空间必须足够大，以容纳源字符串，并且目标空间必须是可修改的；源字符串必须以\0结尾。

下面是strcpy的模拟实现，逐字符进行拷贝：

char* myStrcpy(char* dest, const char* src) {
    char* originalDest = dest;
    while ((*dest++ = *src++)!= '\0');
    return originalDest;
}

这里首先保存目标字符串的起始地址，然后通过循环逐字符拷贝，直到遇到源字符串的\0，并将其也拷贝到目标字符串中，最后返回目标字符串的起始地址。

💯strcat：字符串拼接

strcat函数用于将源字符串追加到目标字符串末尾。例如：

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

int main() {
    char dest[20] = "Hello";
    char src[] = " World";
    strcat(dest, src);
    printf("拼接后的字符串: %s\n", dest);
    return 0;
}

关键点在于目标字符串末尾的\0会被源字符串的第一个字符覆盖，在追加完成后，会在新的字符串末尾补上\0。

下面是strcat的模拟实现：

char* myStrcat(char* dest, const char* src) {
    char* originalDest = dest;
    while (*dest!= '\0') {
        dest++;
    }
    while ((*dest++ = *src++)!= '\0');
    return originalDest;
}

首先找到目标字符串的末尾（即\0的位置），然后从该位置开始，逐字符将源字符串追加到目标字符串后面，直到源字符串的\0也被拷贝过去。

💯strcmp：字符串比较

strcmp函数按照ASCII码值逐字符比较两个字符串，直到出现不同的字符或者遇到\0。返回值具有特定意义：大于0表示第一个字符串大于第二个字符串；等于0表示两个字符串相等；小于0表示第一个字符串小于第二个字符串。例如：

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

int main() {
    char str1[] = "Hello";
    char str2[] = "Hello";
    int result = strcmp(str1, str2);
    if (result == 0) {
        printf("两个字符串相等\n");
    } else if (result > 0) {
        printf("str1大于str2\n");
    } else {
        printf("str1小于str2\n");
    }
    return 0;
}

下面是strcmp的模拟实现：

int myStrcmp(const char* str1, const char* str2) {
    while (*str1!= '\0' && *str2!= '\0') {
        if (*str1!= *str2) {
            return *str1 - *str2;
        }
        str1++;
        str2++;
    }
    if (*str1 == '\0' && *str2 == '\0') {
        return 0;
    } else if (*str1 == '\0') {
        return -1;
    } else {
        return 1;
    }
}

通过循环逐字符比较两个字符串，一旦发现不同字符，立即返回它们的ASCII码差值。如果循环结束没有发现不同字符，再根据两个字符串是否同时到达\0来判断返回值。

💻限定长度的字符串函数

💯strncpy：安全拷贝

strncpy函数用于拷贝指定长度的字符，当源字符串长度小于指定长度时，会在目标字符串后面补\0。例如：

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

int main() {
    char src[] = "Hello";
    char dest[10];
    strncpy(dest, src, 3);
    dest[3] = '\0';
    printf("目标字符串: %s\n", dest);
    return 0;
}

strncpy主要应用于防止目标空间溢出的场景，因为它不会像strcpy那样无条件地拷贝源字符串，而是按照指定的长度进行拷贝。

💯strncat：安全拼接

strncat函数用于追加指定长度的字符到目标字符串末尾，并自动在新字符串末尾补\0。例如：

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

int main() {
    char dest[20] = "Hello";
    char src[] = " World";
    strncat(dest, src, 3);
    printf("拼接后的字符串: %s\n", dest);
    return 0;
}

在实际应用中，可以使用strncat来拼接用户输入的前N个字符，避免因用户输入过长导致缓冲区溢出。

💯strncmp：限定长度比较

strncmp函数仅比较两个字符串的前N个字符。例如：

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

int main() {
    char str1[] = "Hello World";
    char str2[] = "Hello China";
    int result = strncmp(str1, str2, 5);
    if (result == 0) {
        printf("前5个字符相等\n");
    } else if (result > 0) {
        printf("str1的前5个字符大于str2\n");
    } else {
        printf("str1的前5个字符小于str2\n");
    }
    return 0;
}

strncmp适用于需要进行部分字符串比较的场景，比如密码前缀匹配、协议头校验等。

🦜字符串搜索、分割与错误处理

💯strstr：查找子串

strstr函数用于在一个字符串中查找另一个子串首次出现的位置。例如：

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

int main() {
    char str[] = "Hello World";
    char subStr[] = "World";
    char* result = strstr(str, subStr);
    if (result!= NULL) {
        printf("子串首次出现的位置: %ld\n", result - str);
    } else {
        printf("未找到子串\n");
    }
    return 0;
}

下面是strstr的模拟实现，采用暴力匹配算法（双指针法）：

char* myStrstr(const char* haystack, const char* needle) {
    while (*haystack!= '\0') {
        const char* p1 = haystack;
        const char* p2 = needle;
        while (*p1!= '\0' && *p2!= '\0' && *p1 == *p2) {
            p1++;
            p2++;
        }
        if (*p2 == '\0') {
            return (char*)haystack;
        }
        haystack++;
    }
    return NULL;
}

外层循环遍历主字符串，内层循环从主字符串当前位置开始与子串进行逐字符匹配，一旦匹配成功则返回主字符串中匹配的起始位置，若遍历完主字符串都未找到匹配则返回NULL。

💯strtok：字符串分割

strtok函数用于按分隔符切分字符串。例如，解析IP地址"192.168.1.1"为各个IP段：

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

int main() {
    char ip[] = "192.168.1.1";
    char* token = strtok(ip, ".");
    while (token!= NULL) {
        printf("IP段: %s\n", token);
        token = strtok(NULL, ".");
    }
    return 0;
}

使用strtok时需要注意：它会修改原字符串，将分隔符替换为\0，因此如果需要保留原字符串，应先操作副本；并且需要多次调用，每次调用时传入NULL作为第一个参数，以获取下一个分割结果。

💯strerror与perror：错误处理

strerror函数将错误码errno转换为描述信息，例如strerror(errno)可能返回"File not found"。perror函数则直接输出带前缀的错误信息。例如：

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

int main() {
    int fd = open("nonexistent_file.txt", O_RDONLY);
    if (fd == -1) {
        printf("strerror: %s\n", strerror(errno));
        perror("perror: ");
    } else {
        close(fd);
    }
    return 0;
}

在处理文件打开失败、内存分配错误等场景时，strerror和perror能帮助开发者快速定位和解决问题。

🤔常见问题与解决方案

💯缓冲区溢出

当使用strcpy等函数时，如果目标空间不足，就会发生缓冲区溢出。例如：

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

int main() {
    char dest[5];
    char src[] = "Hello";
    strcpy(dest, src);
    return 0;
}

这里目标数组dest的大小为5，不足以容纳源字符串"Hello"（包括\0共6个字符），会导致缓冲区溢出。解决方案是改用strncpy函数，或者根据源字符串长度动态分配足够大的内存。

💯无符号数陷阱

由于strlen等函数返回的是无符号类型size_t，在进行比较时可能出现意外结果。例如：

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

int main() {
    char str1[] = "Hello";
    char str2[] = "World";
    if (strlen(str1) - strlen(str2) > 0) {
        printf("str1长度大于str2\n");
    } else {
        printf("str1长度小于等于str2\n");
    }
    return 0;
}

当strlen(str1)小于strlen(str2)时，由于无符号数相减的结果仍然是无符号数，所以strlen(str1) - strlen(str2)的结果是一个很大的正数，导致判断错误。解决方法是将strlen的返回值强制转换为int类型后再进行比较。

💯未初始化的指针

使用未初始化的指针进行字符串操作会导致未定义行为。例如：

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

int main() {
    char *dest;
    char src[] = "Hello";
    strcpy(dest, src);
    return 0;
}

这里dest指针未初始化，没有指向有效的内存空间，调用strcpy会出错。应先为dest分配内存，例如使用malloc函数分配内存，使用完毕后记得用free释放内存。

💯多线程安全问题

像strtok这类函数不是线程安全的，因为它内部使用了静态变量来保存字符串的解析状态。如果在多线程环境下共享字符串并调用strtok，会导致数据竞争和未定义行为。例如在Linux系统中，可以使用strtok_r函数替代strtok，strtok_r通过传入一个额外的指针参数来保存解析状态，从而避免了静态变量带来的线程安全问题。如果无法使用strtok_r，则可以通过避免多个线程共享同一个需要分割的字符串来解决该问题。

🐍从零实现一个字符串工具库

💯需求分析

我们要实现的字符串工具库需要支持常见的字符串操作，如拷贝、拼接、比较、分割等。同时，为了避免前面提到的安全问题，还需要提供安全版本的函数，比如my_strncpy。

💯代码实现

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

// 安全拷贝函数
char* my_strncpy(char* dest, const char* src, size_t n) {
    char* originalDest = dest;
    while (n > 0 && *src!= '\0') {
        *dest = *src;
        dest++;
        src++;
        n--;
    }
    while (n > 0) {
        *dest = '\0';
        dest++;
        n--;
    }
    return originalDest;
}

// 安全拼接函数
char* my_strncat(char* dest, const char* src, size_t n) {
    char* originalDest = dest;
    while (*dest!= '\0') {
        dest++;
    }
    while (n > 0 && *src!= '\0') {
        *dest = *src;
        dest++;
        src++;
        n--;
    }
    if (n == 0 && *src!= '\0') {
        // 防止源字符串过长，在目标字符串末尾补\0
        *dest = '\0';
    }
    return originalDest;
}

// 比较函数
int my_strcmp(const char* str1, const char* str2) {
    while (*str1!= '\0' && *str2!= '\0') {
        if (*str1!= *str2) {
            return *str1 - *str2;
        }
        str1++;
        str2++;
    }
    if (*str1 == '\0' && *str2 == '\0') {
        return 0;
    } else if (*str1 == '\0') {
        return -1;
    } else {
        return 1;
    }
}

// 分割函数，模仿strtok但不修改原字符串
char* my_strtok(const char* str, const char* delimiters, char** saveptr) {
    if (str!= NULL) {
        *saveptr = (char*)str;
    }
    char* start = *saveptr;
    if (start == NULL) {
        return NULL;
    }
    while (**saveptr!= '\0' && strchr(delimiters, **saveptr)!= NULL) {
        (*saveptr)++;
    }
    start = *saveptr;
    if (**saveptr == '\0') {
        return NULL;
    }
    while (**saveptr!= '\0' && strchr(delimiters, **saveptr) == NULL) {
        (*saveptr)++;
    }
    if (**saveptr!= '\0') {
        **saveptr = '\0';
        (*saveptr)++;
    }
    return start;
}

// 解析CSV文件示例
void parseCSV(const char* csv) {
    char* saveptr;
    char* token = my_strtok(csv, ",", &saveptr);
    while (token!= NULL) {
        printf("CSV字段: %s\n", token);
        token = my_strtok(NULL, ",", &saveptr);
    }
}

// 简单文本编辑器示例，实现字符串拼接模拟添加文本功能
void simpleTextEditor() {
    char buffer[100] = "";
    char input[50];
    while (true) {
        printf("输入文本（输入exit退出）: ");
        scanf("%s", input);
        if (strcmp(input, "exit") == 0) {
            break;
        }
        my_strncat(buffer, input, strlen(input));
        my_strncat(buffer, " ", 1);
        printf("当前文本: %s\n", buffer);
    }
}

🌟总结与延伸学习

💯C字符串的优缺点

C字符串的优点在于其灵活高效，直接操作字符数组，对内存的控制较为精细，在一些对性能要求极高的场景，如嵌入式系统开发中非常适用。然而，其缺点也很明显，需要手动管理内存，容易出现缓冲区溢出、野指针等问题，这增加了编程的难度和出错的风险。

💯现代替代方案

在C++中，std::string提供了更高级的字符串操作接口，它自动管理内存，避免了许多C字符串的陷阱，并且提供了丰富的成员函数，如find、replace、substr等，使用起来更加方便和安全。在Rust语言中，String类型同样提供了安全的字符串操作，Rust的所有权系统从根本上杜绝了缓冲区溢出等内存安全问题。

💯推荐学习路径

想要进一步深入学习C语言字符串相关知识，可以阅读《C陷阱与缺陷》，这本书详细介绍了C语言编程中容易出现的各种问题及解决方案，其中包含了很多与字符串处理相关的内容。《C和指针》则深入讲解了C语言中指针的概念和应用，而字符串处理与指针密切相关，通过学习这本书可以更好地理解字符串在内存中的存储和操作原理。此外，研究Linux内核中的字符串处理代码以及Redis源码中的字符串操作部分，也能从实际的开源项目中学习到优秀的字符串处理技巧和编程规范。