C语言标准库中的 <string.h> 头文件提供了大量用于操作字符串和内存块的函数。熟练掌握这些函数对于高效地进行C语言编程至关重要。本节将深入探讨其中几个常用且功能强大的函数：strstr、strtok、memcpy 和 memmove。

1. strstr()- 在字符串中查找子字符串

char *strstr(const char *haystack, const char *needle);

• haystack: 指向被搜索的主字符串。
• needle: 指向要搜索的子字符串。

strstr() 函数在 haystack 字符串中查找 needle 子字符串第一次出现的位置。

• 返回值：
• 如果找到子字符串，返回一个指向 haystack 中子字符串第一次出现位置的指针。
• 如果未找到子字符串，或者 needle 是一个空字符串（C99及之后标准，早期行为可能不同），返回 NULL。

特性与用途：

• 用于判断一个字符串是否包含另一个字符串。
• 获取子字符串在主字符串中的起始位置，从而可以进行后续的提取或替换操作。
• 大小写敏感。

示例：

 #include <stdio.h>
 #include <string.h>
 
 int main() {
     const char *main_string = "Hello, this is a test string for testing.";
     const char *substring1 = "test";
     const char *substring2 = "world";
     const char *empty_substring = "";
 
     char *found_pos;
 
     // 查找 "test"
     found_pos = strstr(main_string, substring1);
     if (found_pos != NULL) {
         printf("Substring '%s' found at position: %ld\n", substring1, found_pos - main_string);
         printf("Remaining string from found position: %s\n", found_pos);
     } else {
         printf("Substring '%s' not found.\n", substring1);
     }
 
     // 查找 "world"
     found_pos = strstr(main_string, substring2);
     if (found_pos != NULL) {
         printf("Substring '%s' found at position: %ld\n", substring2, found_pos - main_string);
     } else {
         printf("Substring '%s' not found.\n", substring2);
     }
     
     // 查找空字符串 (C99及以后标准，通常返回haystack本身)
     // 行为可能因编译器和标准版本而异，较早的标准可能返回NULL
     // 现代编译器通常遵循C99/C11，空needle匹配haystack的开头
     found_pos = strstr(main_string, empty_substring);
     if (found_pos != NULL) {
         printf("Empty substring found at position: %ld (points to start of haystack)\n", found_pos - main_string);
     } else {
         printf("Empty substring not found or treated as no match.\n");
     }
 
     return 0;
 }

2. strtok()- 分割字符串

char *strtok(char *restrict str, const char *restrict delim);

• str: 第一次调用时，指向要被分割的字符串。后续调用时，应传入 NULL。
• delim: 指向一个包含分隔符集合的字符串。

strtok() 函数用于将一个字符串分割成一系列的“标记”（tokens），这些标记由 delim 字符串中包含的任何一个字符分隔开。

重要特性与警告：

• 修改原字符串：strtok() 会修改它所处理的字符串。它会将找到的分隔符替换为 \0 (空字符)，以便返回的标记是正常的以空字符结尾的字符串。因此，如果你需要保留原始字符串，应该先复制一份。
• 内部静态状态：strtok() 使用一个内部的静态指针来记住下次开始搜索的位置。这意味着：
• 它不是线程安全的。在多线程环境中使用 strtok() 会导致问题。
• 不能同时用 strtok() 分割两个不同的字符串（除非一个分割完成后再开始另一个）。
• C11标准引入了 strtok_s() (以及POSIX中的 strtok_r()) 作为线程安全的替代品。
• 连续分隔符：如果字符串中有连续的分隔符，strtok() 会将它们视为单个分隔符，并且不会返回空标记。
• 开头/结尾分隔符：如果字符串以分隔符开头，这些分隔符会被跳过。如果以分隔符结尾，则最后一个标记之后的分隔符也会被处理。

调用流程：

0. 第一次调用：将待分割的字符串作为第一个参数传递给 strtok()。
1. 后续调用：将 NULL 作为第一个参数传递给 strtok()，以继续从上一次停止的地方分割同一个字符串。
2. 当没有更多标记可返回时，strtok() 返回 NULL。

示例：

 #include <stdio.h>
 #include <string.h>
 
 int main() {
     char str[] = "apple,banana;orange grape-mango";
     char delimiters[] = ",;- "; // 分隔符可以是逗号、分号、连字符或空格
     char *token;
 
     printf("Original string: '%s'\n", str);
 
     // 第一次调用
     token = strtok(str, delimiters);
 
     printf("Tokens:\n");
     while (token != NULL) {
         printf("  '%s'\n", token);
         // 后续调用，传入NULL
         token = strtok(NULL, delimiters);
     }
 
     // 注意：此时原字符串 str 已经被修改
     printf("String after strtok: ");
     // 由于strtok用\0替换了分隔符，直接打印str可能只显示第一个token
     // 需要遍历查看被修改的部分
     char *ptr = str;
     while (*ptr != '\0' || *(ptr+1) != '\0') { // 打印直到连续两个\0 (大致示意)
         if (*ptr == '\0') printf(" [NULL] ");
         else putchar(*ptr);
         ptr++;
         if (ptr - str > sizeof(str)) break; // 防止无限循环
     }
     putchar('\n');
 
     // 另一个例子，处理连续分隔符
     char str2[] = "one,,,two; three";
     printf("\nOriginal string 2: '%s'\n", str2);
     token = strtok(str2, delimiters);
     printf("Tokens from str2:\n");
     while (token != NULL) {
         printf("  '%s'\n", token);
         token = strtok(NULL, delimiters);
     }
 
     return 0;
 }

3. memcpy()- 内存复制

void *memcpy(void *restrict dest, const void *restrict src, size_t n);

• dest: 指向目标内存区域的指针，数据将复制到这里。
• src: 指向源内存区域的指针，数据将从这里复制。
• n: 要复制的字节数。

memcpy() 函数从 src 指向的内存位置复制 n 个字节到 dest 指向的内存位置。

重要特性与警告：

• 内存重叠：如果源内存区域和目标内存区域有重叠，memcpy() 的行为是未定义的。在这种情况下，应该使用 memmove()。
• 不关心数据类型：memcpy() 按字节复制，不关心它复制的是什么类型的数据（整数、浮点数、结构体等）。
• 不处理空字符：与字符串复制函数（如 strcpy）不同，memcpy() 会精确复制 n 个字节，即使中途遇到 \0 也会继续复制。
• 返回值：返回 dest 指针。

示例：

 #include <stdio.h>
 #include <string.h>
 
 typedef struct {
     int id;
     char name[20];
 } Record;
 
 int main() {
     // 复制字符串 (包括末尾的\0，如果n足够大)
     char source_str[] = "Hello World";
     char dest_str[20];
     memcpy(dest_str, source_str, strlen(source_str) + 1); // +1 for null terminator
     printf("Copied string: %s\n", dest_str);
 
     // 复制整数数组
     int source_arr[] = {1, 2, 3, 4, 5};
     int dest_arr[5];
     memcpy(dest_arr, source_arr, sizeof(source_arr));
     printf("Copied array: ");
     for (int i = 0; i < 5; i++) {
         printf("%d ", dest_arr[i]);
     }
     printf("\n");
 
     // 复制结构体
     Record rec_src = {101, "Test Record"};
     Record rec_dest;
     memcpy(&rec_dest, &rec_src, sizeof(Record));
     printf("Copied record: ID=%d, Name=%s\n", rec_dest.id, rec_dest.name);
     
     // 潜在的重叠问题 (不应使用memcpy)
     char buffer[] = "123456789";
     // 错误示例: memcpy(buffer + 2, buffer, 5); // dest 和 src 重叠，行为未定义
     // 正确应使用 memmove for overlapping regions
     // memmove(buffer + 2, buffer, 5); 
     // printf("Buffer after potentially problematic memcpy (or correct memmove): %s\n", buffer);
 
     return 0;
 }

4. memmove()- 安全的内存复制（处理重叠）

void *memmove(void *dest, const void *src, size_t n);

• dest: 指向目标内存区域的指针。
• src: 指向源内存区域的指针。
• n: 要复制的字节数。

memmove() 函数与 memcpy() 非常相似，它也是从 src 复制 n 个字节到 dest。关键区别在于：memmove() 可以正确处理源内存区域和目标内存区域重叠的情况。

如果 src 和 dest 指向的区域可能重叠，必须使用 memmove() 而不是 memcpy() 来保证正确的行为。

memmove() 通过先将数据复制到一个临时缓冲区（如果区域重叠且方向不安全），或者通过判断重叠方向并选择合适的复制顺序（从前向后或从后向前）来实现安全的复制。

• 返回值：返回 dest 指针。

示例：

 #include <stdio.h>
 #include <string.h>
 
 int main() {
     char str[] = "abcdefghij";
     printf("Original string: %s\n", str);
 
     // 示例1: dest 在 src 之后，且有重叠 (例如，将 "abcde" 移动到 "cdefg" 的位置)
     // src:  a b c d e f g h i j
     // dest:     a b c d e
     // memmove(str + 2, str, 5); // 结果应为 "ababcdehij"
     // memcpy 在这种情况下行为未定义，结果可能不正确
     
     // 我们用一个更清晰的例子演示重叠
     char buffer1[20] = "HelloWorld";
     // 将 "Hello" 移动到 "lloWo" 的位置 (buffer1+2)
     // src:  H e l l o W o r l d
     // dest:     H e l l o
     printf("Buffer1 before memmove: %s\n", buffer1);
     memmove(buffer1 + 2, buffer1, 5); 
     printf("Buffer1 after memmove (dest > src, overlap): %s\n", buffer1); // 预期: "HeHelloorld"
 
     char buffer2[20] = "HelloWorld";
     // 将 "World" 移动到 "lloWo" 的位置 (buffer2)
     // src:          W o r l d
     // dest: H e l l o
     printf("Buffer2 before memmove: %s\n", buffer2);
     memmove(buffer2, buffer2 + 5, 5); 
     printf("Buffer2 after memmove (dest < src, overlap): %s\n", buffer2); // 预期: "WorldWorld"
 
     // 如果不重叠，memmove 和 memcpy 效果相同
     char src_no_overlap[] = "Source";
     char dest_no_overlap[10];
     memmove(dest_no_overlap, src_no_overlap, strlen(src_no_overlap) + 1);
     printf("Non-overlapping copy with memmove: %s\n", dest_no_overlap);
 
     return 0;
 }

总结

• strstr(): 用于在字符串中查找子串。
• strtok(): 用于分割字符串，但会修改原串且非线程安全（应考虑 strtok_s 或 strtok_r）。
• memcpy(): 用于高效复制内存块，但源和目标区域不能重叠。
• memmove(): 用于复制内存块，可以安全处理源和目标区域重叠的情况。

理解这些函数的行为、参数和潜在问题，可以帮助你编写更安全、更高效的C代码来处理字符串和内存数据。