C语言字符串处理

1. 字符串的基本概念

C语言中的字符串是由字符数组表示的，并且以空字符 \0 作为结束标志。C语言本身并没有直接的字符串类型，所有的字符串操作都是通过字符数组来实现的。

字符数组与字符串的区别

在C语言中，字符数组和字符串有着紧密的联系，但它们并不完全相同：

字符数组是一个存储字符的数组，并不一定是一个字符串。
字符串是一个以空字符 \0 结尾的字符数组。

以下是一个简单的字符串定义示例：

1char str[] = "Hello, World!";

在上述例子中，字符数组 str 包含了 H, e, l, l, o, ,, , W, o, r, l, d, ! 和结尾的空字符 \0。

2. 常见的字符串操作函数

C标准库提供了一系列处理字符串的函数，以下是一些常用的字符串操作函数：

2.1 `strlen`：计算字符串长度

strlen 函数用于计算字符串的长度（不包括结尾的空字符）。

示例代码：

1#include <stdio.h>
2#include <string.h>
3
4int main() {
5    char str[] = "Hello, World!";
6    printf("字符串长度: %lu\n", strlen(str));
7    return 0;
8}

输出：

1字符串长度: 13

2.2 `strcpy` 和 `strncpy`：复制字符串

strcpy 用于将源字符串复制到目标字符串，目标数组需要足够大以容纳源字符串及其空字符。
strncpy 是更安全的版本，可以指定最大复制字符数，防止缓冲区溢出。

示例代码：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char src[] = "Hello, C!";
 6    char dest[20];
 7
 8    // 使用 strcpy
 9    strcpy(dest, src);
10    printf("复制后的字符串: %s\n", dest);
11
12    // 使用 strncpy，最多复制5个字符
13    strncpy(dest, src, 5);
14    dest[5] = '\0';  // 确保字符串以空字符结尾
15    printf("部分复制后的字符串: %s\n", dest);
16
17    return 0;
18}

输出：

1复制后的字符串: Hello, C!
2部分复制后的字符串: Hello

2.3 `strcat` 和 `strncat`：拼接字符串

strcat 用于将源字符串拼接到目标字符串末尾。
strncat 限制拼接的字符数量，提供更安全的拼接方式。

示例代码：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char str1[20] = "Hello, ";
 6    char str2[] = "World!";
 7
 8    // 使用 strcat
 9    strcat(str1, str2);
10    printf("拼接后的字符串: %s\n", str1);
11
12    // 使用 strncat，最多拼接3个字符
13    strncat(str1, str2, 3);
14    printf("部分拼接后的字符串: %s\n", str1);
15
16    return 0;
17}

输出：

1拼接后的字符串: Hello, World!
2部分拼接后的字符串: Hello, World!Wor

2.4 `strcmp`：比较两个字符串

strcmp 用于比较两个字符串的字典序大小。返回值：

0：两个字符串相等。
正数：第一个字符串大于第二个字符串。
负数：第一个字符串小于第二个字符串。

示例代码：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char str1[] = "Hello";
 6    char str2[] = "World";
 7
 8    int result = strcmp(str1, str2);
 9
10    if (result == 0) {
11        printf("两个字符串相等\n");
12    } else if (result > 0) {
13        printf("第一个字符串大于第二个字符串\n");
14    } else {
15        printf("第一个字符串小于第二个字符串\n");
16    }
17
18    return 0;
19}

输出：

1第一个字符串小于第二个字符串

2.5 `strstr`：查找子字符串

strstr 用于查找子字符串在主字符串中的位置。如果找到，返回子字符串的起始位置指针；否则返回 NULL。

示例代码：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char str[] = "Hello, World!";
 6    char *substr = "World";
 7
 8    char *position = strstr(str, substr);
 9    if (position) {
10        printf("找到子字符串: %s\n", position);
11    } else {
12        printf("未找到子字符串\n");
13    }
14
15    return 0;
16}

输出：

1找到子字符串: World!

2.6 `strtok`：分割字符串

strtok 用于将字符串分割成多个子字符串。

示例代码：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char str[] = "Hello, World! Welcome to C programming.";
 6    char *token = strtok(str, " ");
 7
 8    while (token != NULL) {
 9        printf("%s\n", token);
10        token = strtok(NULL, " ");
11    }
12
13    return 0;
14}

输出:

1Hello,
2World!
3Welcome
4to
5C
6programming.

3. 字符串的输入与输出

在C语言中，字符串的输入和输出是非常常见的操作。主要有几种方法可以用于字符串的输入和输出：scanf、gets（不推荐使用）和 fgets 用于输入字符串，printf 和 puts 用于输出字符串。

3.1 使用 `scanf` 输入字符串

scanf 可以读取字符串，但它会在遇到空格、制表符或换行符时停止读取，容易引发输入不完整的问题。

示例代码：

1#include <stdio.h>
2
3int main() {
4    char str[50];
5    printf("请输入一个字符串（无空格）：");
6    scanf("%s", str);
7    printf("你输入的字符串是：%s\n", str);
8    return 0;
9}

输出：

1请输入一个字符串（无空格）：Hello
2你输入的字符串是：Hello

3.2 使用 `gets` 输入字符串

gets 函数可以读取一行输入，包括空格，但由于不进行边界检查，存在缓冲区溢出风险，不建议使用。

示例代码：

1#include <stdio.h>
2
3int main() {
4    char str[50];
5    printf("请输入一个字符串（包含空格）：");
6    fgets(str, sizeof(str), stdin);
7    printf("你输入的字符串是：%s", str);
8    return 0;
9}

输出：

1请输入一个字符串（包含空格）：Hello World
2你输入的字符串是：Hello World

3.3 使用 `fgets` 输入字符串

fgets 是推荐的读取字符串的方法，它可以指定读取的最大字符数，从而避免缓冲区溢出的问题。它会读取包含空格的整行输入，但会保留换行符。

示例代码：

1#include <stdio.h>
2
3int main() {
4    char str[50];
5    printf("请输入一个字符串（包含空格）：");
6    fgets(str, sizeof(str), stdin);
7    printf("你输入的字符串是：%s", str);
8    return 0;
9}

输出：

1请输入一个字符串（包含空格）：Hello World
2你输入的字符串是：Hello World

3.4 使用 `printf` 输出字符串

printf 是最常用的输出字符串的方法。它可以通过格式化输出字符串和变量值。

示例代码：

1#include <stdio.h>
2
3int main() {
4    char str[] = "Hello, C!";
5    printf("输出字符串：%s\n", str);
6    return 0;
7}

输出：

1输出字符串：Hello, C!

3.5 使用 `puts` 输出字符串

puts 是另一个输出字符串的函数，它在输出字符串后会自动添加换行符。

示例代码：

1#include <stdio.h>
2
3int main() {
4    char str[] = "Hello, World!";
5    puts(str);
6    return 0;
7}

输出：

1Hello, World!

总结：对于字符串输入，推荐使用 fgets 以避免安全问题；输出时，printf 和 puts 各有特点，选择合适的方式即可。

4. 字符串的常见操作及注意事项

在C语言中，字符串操作不仅限于标准库函数，还可以通过自定义函数实现更复杂的操作。以下是一些常见的字符串操作及需要注意的事项。

4.1 手动反转字符串

反转字符串是一个常见的操作，下面的代码展示了如何手动实现字符串的反转：

 1#include <stdio.h>
 2#include <string.h>
 3
 4void reverse(char *str) {
 5    int start = 0;
 6    int end = strlen(str) - 1;
 7    while (start < end) {
 8        // 交换字符
 9        char temp = str[start];
10        str[start] = str[end];
11        str[end] = temp;
12        start++;
13        end--;
14    }
15}
16
17int main() {
18    char str[] = "Hello, World!";
19    reverse(str);
20    printf("反转后的字符串: %s\n", str);
21    return 0;
22}

输出：

1反转后的字符串: !dlroW ,olleH

4.2 字符串大小写转换

通过遍历字符串，将小写字母转换为大写字母，反之亦然：

 1#include <stdio.h>
 2#include <ctype.h>
 3
 4void toUpperCase(char *str) {
 5    for (int i = 0; str[i] != '\0'; i++) {
 6        str[i] = toupper(str[i]);
 7    }
 8}
 9
10void toLowerCase(char *str) {
11    for (int i = 0; str[i] != '\0'; i++) {
12        str[i] = tolower(str[i]);
13    }
14}
15
16int main() {
17    char str1[] = "Hello, World!";
18    char str2[] = "Hello, World!";
19    toUpperCase(str1);
20    toLowerCase(str2);
21    printf("转换为大写: %s\n", str1);
22    printf("转换为小写: %s\n", str2);
23    return 0;
24}

输出：

1转换为大写: HELLO, WORLD!
2转换为小写: hello, world!

4.3 字符串和字符数组的区别与联系

字符数组 是一个存储字符的数组，定义时必须指定大小或初始化。
字符串 是一个以空字符 \0 结尾的字符数组。

在C语言中，字符串与字符数组的主要区别是：字符串必须以空字符结尾，而字符数组不一定。比如：

1char arr[5] = {'H', 'e', 'l', 'l', 'o'}; // 不是字符串，没有空字符结尾
2char str[6] = "Hello"; // 是字符串，以空字符 '\0' 结尾

4.4 字符串操作中的安全问题

处理字符串时，常见的安全问题是 缓冲区溢出。例如，当复制或拼接字符串时，如果目标数组空间不足，就会导致溢出，可能引发程序崩溃或其他安全漏洞。

示例：缓冲区溢出

以下代码中，目标数组 dest 太小，导致溢出：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char dest[5]; // 缓冲区太小
 6    char src[] = "Hello, World!";
 7    strcpy(dest, src); // 溢出，危险操作
 8    printf("复制后的字符串: %s\n", dest);
 9    return 0;
10}

正确做法：使用 strncpy 或确保目标数组足够大：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char dest[20];
 6    char src[] = "Hello, World!";
 7    strncpy(dest, src, sizeof(dest) - 1); // 确保不会溢出
 8    dest[sizeof(dest) - 1] = '\0'; // 手动添加结尾的空字符
 9    printf("安全复制后的字符串: %s\n", dest);
10    return 0;
11}

输出：

1安全复制后的字符串: Hello, World!

4.5 其他注意事项

边界检查：所有字符串操作都应考虑数组的边界，避免读取或写入越界。
内存管理：对于动态分配的字符串，使用完毕后记得释放内存，以避免内存泄漏。

5. 自定义字符串操作函数

在C语言中，除了标准库函数，我们还可以通过编写自定义函数来实现更复杂或特定需求的字符串操作。这部分将介绍如何编写一些常用的自定义字符串操作函数，如字符串查找、替换和删除等。

5.1 查找子字符串的自定义实现

虽然标准库提供了 strstr 函数来查找子字符串，但我们可以自己实现一个简单的查找函数，返回子字符串的起始位置索引。

 1#include <stdio.h>
 2
 3int findSubstring(const char *str, const char *substr) {
 4    int i, j;
 5    for (i = 0; str[i] != '\0'; i++) {
 6        for (j = 0; substr[j] != '\0' && str[i + j] == substr[j]; j++);
 7        if (substr[j] == '\0') {
 8            return i; // 找到子字符串，返回起始位置
 9        }
10    }
11    return -1; // 未找到子字符串
12}
13
14int main() {
15    char str[] = "Hello, World!";
16    char substr[] = "World";
17    int position = findSubstring(str, substr);
18    if (position != -1) {
19        printf("子字符串 \"%s\" 的起始位置是: %d\n", substr, position);
20    } else {
21        printf("未找到子字符串 \"%s\"\n", substr);
22    }
23    return 0;
24}

输出：

1子字符串 "World" 的起始位置是: 7

5.2 替换子字符串的自定义实现

替换子字符串是一个稍微复杂的操作，以下代码展示了如何实现子字符串的简单替换：

 1#include <stdio.h>
 2#include <string.h>
 3
 4void replaceSubstring(char *str, const char *oldSubstr, const char *newSubstr) {
 5    char buffer[100];
 6    char *pos;
 7
 8    // 查找子字符串的位置
 9    if ((pos = strstr(str, oldSubstr)) != NULL) {
10        // 复制替换点之前的内容到缓冲区
11        strncpy(buffer, str, pos - str);
12        buffer[pos - str] = '\0';
13
14        // 添加新的子字符串
15        strcat(buffer, newSubstr);
16
17        // 添加剩余的原字符串
18        strcat(buffer, pos + strlen(oldSubstr));
19
20        // 将结果复制回原字符串
21        strcpy(str, buffer);
22    }
23}
24
25int main() {
26    char str[100] = "Hello, World!";
27    replaceSubstring(str, "World", "C");
28    printf("替换后的字符串: %s\n", str);
29    return 0;
30}

输出：

1替换后的字符串: Hello, C!

5.3 删除指定字符的自定义实现

通过遍历字符串，可以删除指定的字符，如空格、特定字母等。

 1#include <stdio.h>
 2
 3void removeCharacter(char *str, char charToRemove) {
 4    int i, j = 0;
 5    while (str[i]) {
 6        if (str[i] != charToRemove) {
 7            str[j++] = str[i];
 8        }
 9        i++;
10    }
11    str[j] = '\0';
12}
13
14int main() {
15    char str[] = "Hello, World!";
16    removeCharacter(str, 'o');
17    printf("删除字符 'o' 后的字符串: %s\n", str);
18    return 0;
19}

输出：

1删除字符 'o' 后的字符串: Hell, Wrld!

5.4 计算字符串中单词数量

以下是一个自定义函数，用于计算字符串中的单词数量（以空格分隔为准）：

 1#include <stdio.h>
 2#include <ctype.h>
 3
 4int countWords(const char *str) {
 5    int count = 0, inWord = 0;
 6    while (*str) {
 7        if (!isspace(*str) && !inWord) {
 8            inWord = 1; // 进入单词
 9            count++;
10        } else if (isspace(*str)) {
11            inWord = 0; // 离开单词
12        }
13        str++;
14    }
15    return count;
16}
17
18int main() {
19    char str[] = "Hello, World! Welcome to C programming.";
20    printf("字符串中的单词数量: %d\n", countWords(str));
21    return 0;
22}

输出：

1字符串中的单词数量: 6

5.5 字符串转整数（类似 `atoi` 的实现）

C语言标准库中有 atoi 函数用于将字符串转换为整数，以下是自定义的实现：

 1#include <stdio.h>
 2
 3int myAtoi(const char *str) {
 4    int result = 0;
 5    int sign = 1;
 6    
 7    // 处理空白字符
 8    while (isspace(*str)) str++;
 9    
10    // 处理符号
11    if (*str == '-' || *str == '+') {
12        sign = (*str == '-') ? -1 : 1;
13        str++;
14    }
15    
16    // 处理数字字符
17    while (*str >= '0' && *str <= '9') {
18        result = result * 10 + (*str - '0');
19        str++;
20    }
21    
22    return result * sign;
23}
24
25int main() {
26    char str[] = "  -1234";
27    printf("字符串转整数: %d\n", myAtoi(str));
28    return 0;
29}

输出：

1字符串转整数: -1234

6. 字符串处理的性能优化

在C语言中，字符串处理的性能优化对于提升程序效率至关重要，尤其在处理大量数据或高频操作时。以下是一些常见的优化策略和技术，以帮助提高字符串处理的性能。

6.1 避免不必要的字符串复制

字符串复制是一个常见的操作，但频繁且不必要的复制会严重影响性能。使用指针操作或库函数如 memcpy 来代替手动复制字符可以提高效率。

示例：使用指针代替字符串复制

 1#include <stdio.h>
 2#include <string.h>
 3
 4void copyString(char *dest, const char *src) {
 5    while ((*dest++ = *src++) != '\0');
 6}
 7
 8int main() {
 9    char src[] = "Optimize!";
10    char dest[50];
11    copyString(dest, src);
12    printf("复制后的字符串: %s\n", dest);
13    return 0;
14}

输出：

1复制后的字符串: Optimize!

使用指针操作字符串能够减少不必要的索引运算，提升遍历效率。

6.3 减少内存分配与释放

频繁的动态内存分配和释放会导致性能瓶颈。尽量避免频繁分配小块内存，而是尽量一次性分配足够的空间或者复用内存。

示例：复用内存缓冲区

 1#include <stdio.h>
 2#include <string.h>
 3
 4void processStrings(const char *input1, const char *input2, char *buffer, int bufferSize) {
 5    snprintf(buffer, bufferSize, "%s %s", input1, input2);
 6    printf("处理后的字符串: %s\n", buffer);
 7}
 8
 9int main() {
10    char buffer[100];
11    processStrings("Hello", "World", buffer, sizeof(buffer));
12    processStrings("Goodbye", "Universe", buffer, sizeof(buffer)); // 复用缓冲区
13    return 0;
14}

输出：

1处理后的字符串: Hello World
2处理后的字符串: Goodbye Universe

通过复用缓冲区，可以减少多次内存分配和释放的开销，提高性能。

6.4 使用高效的字符串查找和比较算法

对于复杂的字符串查找和比较，使用高效的算法可以显著提高性能。例如，使用 KMP 算法替代简单的暴力查找算法。

示例：KMP算法实现字符串查找

 1#include <stdio.h>
 2#include <string.h>
 3
 4// 生成部分匹配表（即"前缀表"）
 5void computeLPSArray(const char *pattern, int M, int *lps) {
 6    int length = 0; 
 7    lps[0] = 0; 
 8    int i = 1;
 9    while (i < M) {
10        if (pattern[i] == pattern[length]) {
11            length++;
12            lps[i] = length;
13            i++;
14        } else {
15            if (length != 0) {
16                length = lps[length - 1];
17            } else {
18                lps[i] = 0;
19                i++;
20            }
21        }
22    }
23}
24
25// KMP算法进行字符串查找
26void KMPSearch(const char *pattern, const char *text) {
27    int M = strlen(pattern);
28    int N = strlen(text);
29    int lps[M];
30    computeLPSArray(pattern, M, lps);
31
32    int i = 0; // index for text[]
33    int j = 0; // index for pattern[]
34    while (i < N) {
35        if (pattern[j] == text[i]) {
36            j++;
37            i++;
38        }
39
40        if (j == M) {
41            printf("找到匹配的子字符串，起始位置为: %d\n", i - j);
42            j = lps[j - 1];
43        } else if (i < N && pattern[j] != text[i]) {
44            if (j != 0)
45                j = lps[j - 1];
46            else
47                i = i + 1;
48        }
49    }
50}
51
52int main() {
53    char text[] = "ABABDABACDABABCABAB";
54    char pattern[] = "ABABCABAB";
55    KMPSearch(pattern, text);
56    return 0;
57}

输出：

1找到匹配的子字符串，起始位置为: 10

KMP算法通过减少不必要的字符匹配，提高了字符串查找的效率。

6.5 使用合适的数据结构

在需要进行大量字符串操作时，选择合适的数据结构（如链表、哈希表或自定义的字符缓冲区）可以大幅提高性能。例如，使用哈希表进行字符串查找和去重，可以比线性查找更快。

示例：使用哈希表实现简单的字符串去重

 1#include <stdio.h>
 2#include <string.h>
 3#include <stdlib.h>
 4
 5#define TABLE_SIZE 100
 6
 7typedef struct Node {
 8    char *key;
 9    struct Node *next;
10} Node;
11
12Node *hashTable[TABLE_SIZE];
13
14// 简单哈希函数
15unsigned int hash(const char *key) {
16    unsigned int hash = 0;
17    while (*key) {
18        hash = (hash << 5) + *key++;
19    }
20    return hash % TABLE_SIZE;
21}
22
23// 插入键到哈希表
24void insert(const char *key) {
25    unsigned int index = hash(key);
26    Node *newNode = (Node *)malloc(sizeof(Node));
27    newNode->key = strdup(key);
28    newNode->next = hashTable[index];
29    hashTable[index] = newNode;
30}
31
32// 查找键是否存在
33int exists(const char *key) {
34    unsigned int index = hash(key);
35    Node *node = hashTable[index];
36    while (node) {
37        if (strcmp(node->key, key) == 0) {
38            return 1;
39        }
40        node = node->next;
41    }
42    return 0;
43}
44
45int main() {
46    const char *words[] = {"apple", "banana", "orange", "apple", "banana", "grape"};
47    for (int i = 0; i < 6; i++) {
48        if (!exists(words[i])) {
49            insert(words[i]);
50            printf("添加新单词: %s\n", words[i]);
51        } else {
52            printf("单词 %s 已存在，跳过\n", words[i]);
53        }
54    }
55    return 0;
56}

输出：

1添加新单词: apple
2添加新单词: banana
3添加新单词: orange
4单词 apple 已存在，跳过
5单词 banana 已存在，跳过
6添加新单词: grape

通过使用哈希表实现去重，避免了重复插入的开销，提高了性能。

6.6 其他优化技巧

减少不必要的字符串比较：提前退出比较循环或在合适时机返回结果。
使用静态或全局数组：减少栈空间使用和函数调用的开销。
减少函数调用：将频繁调用的短函数内联以减少调用开销。

这些优化策略在字符串处理上都能起到明显的效果，但也要根据具体的应用场景选择合适的优化方法，避免过早或过度优化。

7. 字符串处理中的常见错误与调试技巧

在C语言中，字符串处理常常会出现一些典型的错误，尤其是在涉及内存管理和边界检查时。这部分将介绍常见的错误类型，以及如何调试和避免这些问题。

7.1 常见错误类型

注：更常见的缓冲区溢出见4.4 字符串操作中的安全问题

7.1.1 空指针操作

空指针操作是字符串处理中的常见错误，通常由于尝试访问未初始化或已释放的指针导致。这会导致程序崩溃或未定义行为。

错误示例：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char *str = NULL; // 空指针
 6    strcpy(str, "Hello, World!"); // 对空指针进行操作
 7    printf("字符串: %s\n", str);
 8    return 0;
 9}
10
11```c

解决方法：

在使用指针前检查是否为空。
在操作前初始化指针或分配内存。

7.1.2 超出字符串边界的访问

访问字符串边界之外的内存是一个常见的错误，可能会导致程序崩溃或返回错误的数据。

错误示例：

1#include <stdio.h>
2
3int main() {
4    char str[5] = "test";
5    printf("非法访问: %c\n", str[5]); // 超出边界访问
6    return 0;
7}

解决方法：

确保访问的索引在字符串的有效范围内。
使用 strlen 等函数检查字符串长度。

7.1.3 使用未初始化的字符数组

使用未初始化的字符数组进行字符串操作可能会导致不可预测的行为，因为数组中可能包含垃圾值。

错误示例：

1#include <stdio.h>
2
3int main() {
4    char str[10]; // 未初始化
5    printf("字符串内容: %s\n", str); // 打印可能包含垃圾值的字符串
6    return 0;
7}

解决方法：

初始化字符数组，或使用 memset 清零。
直接用字符串字面值初始化，如 char str[10] = "";。

7.1.4 字符串截断

使用 strncpy 等函数时，如果目标缓冲区较小，可能会导致字符串未正确以 \0 结尾，从而引发未定义行为。

错误示例：

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char src[] = "This is a long string";
 6    char dest[10];
 7    strncpy(dest, src, sizeof(dest)); // 不会自动添加 '\0'
 8    printf("截断的字符串: %s\n", dest); // 输出不定
 9    return 0;
10}

解决方法：

确保目标字符串总是以 \0 结尾。
手动添加 \0，如 dest[sizeof(dest) - 1] = '\0';。

7.2 调试技巧

7.2.1 使用调试器

调试器如 gdb 是定位C程序错误的强大工具。通过设置断点、逐步执行代码、查看变量值，可以快速定位字符串处理中的问题。

示例：使用 gdb 调试程序

1gcc -g program.c -o program
2gdb ./program
3(gdb) break main
4(gdb) run
5(gdb) next
6(gdb) print str

7.2.2 使用 Valgrind 检测内存错误

Valgrind 是一个用于检测内存错误的工具，可以帮助发现内存泄漏和无效的内存访问。

示例：使用 Valgrind 进行内存检查

1valgrind --leak-check=full ./program

7.2.3 使用 `assert` 进行边界检查

在开发过程中，使用 assert 可以在运行时检查假设条件是否成立，这对于调试字符串边界问题非常有用。

示例：使用 assert 检查边界

 1#include <stdio.h>
 2#include <assert.h>
 3#include <string.h>
 4
 5void copyString(char *dest, const char *src, size_t destSize) {
 6    assert(strlen(src) < destSize); // 确保源字符串不会超出目标缓冲区
 7    strcpy(dest, src);
 8}
 9
10int main() {
11    char buffer[10];
12    copyString(buffer, "Test", sizeof(buffer));
13    printf("复制后的字符串: %s\n", buffer);
14    return 0;
15}

7.2.4 启用编译器警告

使用 -Wall 和 -Wextra 等编译选项可以启用编译器的警告，帮助识别潜在的字符串处理问题。

示例：启用编译器警告

1gcc -Wall -Wextra -o program program.c

7.2.5 检查字符串操作的返回值

在调用字符串函数时，检查返回值可以帮助发现意外的错误，例如未成功查找子字符串或操作失败等。

示例：检查 strchr 返回值

 1#include <stdio.h>
 2#include <string.h>
 3
 4int main() {
 5    char str[] = "Hello, World!";
 6    char *pos = strchr(str, 'x'); // 查找不存在的字符
 7    if (pos != NULL) {
 8        printf("找到字符 'x'\n");
 9    } else {
10        printf("未找到字符 'x'\n");
11    }
12    return 0;
13}

输出：

1未找到字符 'x'

(持续完善中……)

最后修改于 2024-08-30 11:38

1. 字符串的基本概念

字符数组与字符串的区别

2. 常见的字符串操作函数

2.1 strlen：计算字符串长度

2.2 strcpy 和 strncpy：复制字符串

2.3 strcat 和 strncat：拼接字符串

2.4 strcmp：比较两个字符串

2.5 strstr：查找子字符串

2.6 strtok：分割字符串

3. 字符串的输入与输出

3.1 使用 scanf 输入字符串

3.2 使用 gets 输入字符串

3.3 使用 fgets 输入字符串

3.4 使用 printf 输出字符串

3.5 使用 puts 输出字符串

4. 字符串的常见操作及注意事项

4.1 手动反转字符串

4.2 字符串大小写转换

4.3 字符串和字符数组的区别与联系

4.4 字符串操作中的安全问题

示例：缓冲区溢出

4.5 其他注意事项

5. 自定义字符串操作函数

5.1 查找子字符串的自定义实现

5.2 替换子字符串的自定义实现

5.3 删除指定字符的自定义实现

5.4 计算字符串中单词数量

5.5 字符串转整数（类似 atoi 的实现）

6. 字符串处理的性能优化

6.1 避免不必要的字符串复制

示例：使用指针代替字符串复制

6.3 减少内存分配与释放

示例：复用内存缓冲区

6.4 使用高效的字符串查找和比较算法

示例：KMP算法实现字符串查找

6.5 使用合适的数据结构

示例：使用哈希表实现简单的字符串去重

6.6 其他优化技巧

7. 字符串处理中的常见错误与调试技巧

7.1 常见错误类型

7.1.1 空指针操作

7.1.2 超出字符串边界的访问

7.1.3 使用未初始化的字符数组

7.1.4 字符串截断

7.2 调试技巧

7.2.1 使用调试器

7.2.2 使用 Valgrind 检测内存错误

7.2.3 使用 assert 进行边界检查

7.2.4 启用编译器警告

7.2.5 检查字符串操作的返回值

2.1 `strlen`：计算字符串长度

2.2 `strcpy` 和 `strncpy`：复制字符串

2.3 `strcat` 和 `strncat`：拼接字符串

2.4 `strcmp`：比较两个字符串

2.5 `strstr`：查找子字符串

2.6 `strtok`：分割字符串

3.1 使用 `scanf` 输入字符串

3.2 使用 `gets` 输入字符串

3.3 使用 `fgets` 输入字符串

3.4 使用 `printf` 输出字符串

3.5 使用 `puts` 输出字符串

5.5 字符串转整数（类似 `atoi` 的实现）

7.2.3 使用 `assert` 进行边界检查