2025-02-25 学习记录--C/C++-用C语言实现删除字符串中的子串+C 库函数：strstr()、memmove()、strcpy()、memset()、strlen()

用C语言实现删除字符串中的子串

在C语言中，你可以使用strstr函数来查找子串，然后用memmove或strcpy来覆盖或删除找到的子串。

一、举例 🐰

#include <stdio.h>  // 包含标准输入输出库，用于使用 printf 函数
#include <string.h> // 包含字符串处理库，用于使用 strstr 和 memmove 函数
#include <stdlib.h> // 包含标准库，用于使用 exit 函数

// 定义一个函数 removeSubstring，用于从字符串中删除子串
void removeSubstring(char *str, const char *sub) {
    char *pos = strstr(str, sub); // 使用 strstr 函数查找子串 sub 在字符串 str 中的位置
                                  // 如果找到，返回子串的起始地址；如果未找到，返回 NULL

    if (pos != NULL) { // 检查是否找到子串
        char *dest = pos + strlen(sub); // 计算子串 sub 之后的字符的起始地址
                                        // pos 是子串的起始地址，strlen(sub) 是子串的长度
                                        // dest 指向子串之后的字符

        memmove(pos, dest, strlen(dest) + 1); // 使用 memmove 函数将子串之后的字符移动到子串的位置
                                              // strlen(dest) + 1 表示移动的字节数（包括子串之后的字符和字符串结束符 '\0'）
    } else {
        printf("Substring not found.\n"); // 如果没有找到子串，输出提示信息
        // exit(EXIT_FAILURE); // 可选：如果找不到子串，调用 exit 函数终止程序
    }
}

// 主函数
int main() {
    char str[] = "Hello, World!"; // 定义一个字符串 str，初始值为 "Hello, World!"

    removeSubstring(str, "World"); // 调用 removeSubstring 函数，从 str 中删除子串 "World"

    printf("Modified string: %s\n", str); // 输出修改后的字符串 str（删除子串后的结果）

    return 0; // 返回 0，表示程序正常结束
}

二、知识点 📚

（一）、C 库函数 - strstr() 🍭

C 标准库 - <string.h>

strstr() 是 C 标准库中的一个字符串处理函数，用于在一个字符串中查找子字符串的第一次出现位置。

下面是 strstr() 函数的声明：👇🏻
char *strstr(const char *haystack, const char *needle);

• strstr() 函数用于在字符串 haystack 中查找子字符串 needle 的第一次出现位置，不包含终止符 \0。
  • 🍬 如果找到，则返回指向该位置的指针；
  • 🍬 如果未找到，则返回 NULL。
• haystack – 要搜索的主字符串。
• needle – 要查找的子字符串。

举例1 🌰

#include <stdio.h>  // 包含标准输入输出库，用于使用 printf 函数
#include <string.h> // 包含字符串处理库，用于使用 strstr 函数

int main()
{
    const char haystack[20] = "YOU CAN GET IT"; // 定义一个常量字符数组 haystack，初始值为 "YOU CAN GET IT"
                                                // haystack 是主字符串，用于在其中查找子串
    const char needle[10] = "CAN";              // 定义一个常量字符数组 needle，初始值为 "CAN"
                                                // needle 是要查找的子串
    char *ret;                                  // 定义一个字符指针 ret，用于存储 strstr 函数的返回值

    ret = strstr(haystack, needle);             // 使用 strstr 函数在 haystack 中查找子串 needle
                                                // 如果找到，返回子串的起始地址；如果未找到，返回 NULL

    printf("子字符串是： %s\n", ret);             // 输出找到的子字符串
                                                // 如果 ret 不为 NULL，输出从子串起始位置到主字符串末尾的内容
                                                // 如果 ret 为 NULL，输出未定义行为（可能为空或乱码）

    return 0;                                   // 返回 0，表示程序正常结束
}

举例2 🌰

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

int main() {
    const char *haystack = "Hello, world! This is a test string.";
    const char *needle = "world";

    // 在 haystack 中查找 needle
    char *result = strstr(haystack, needle);

    if (result != NULL) {
        printf("Substring found: %s\n", result);
    } else {
        printf("Substring not found.\n");
    }

    return 0;
}

（二）、C 库函数 - memmove() 🍭

C 标准库 - <string.h>

下面是 memmove() 函数的声明：👇🏻
void *memmove(void *str1, const void *str2, size_t n)

• memmove() 函数用于实现从 str2 复制 n 个字符到 str1，该函数返回一个指向目标存储区 str1 的指针。。
• str1 – 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
• str2 – 指向要复制的数据源，类型强制转换为 void* 指针。
• n – 要被复制的字节数。

举例1 🌰

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

int main ()
{
    const char dest[] = "oldstring";
    const char src[]  = "newstring";

    printf("Before memmove dest = %s, src = %s\n", dest, src);
    memmove(dest, src, 9); // 从 src 复制 9 个字符到 dest
    printf("After memmove dest = %s, src = %s\n", dest, src);

    return(0);
}

举例2 🌰

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

int main ()
{
    const char dest[] = "oldstring";
    const char src[]  = "newstring";

    printf("Before memmove dest = %s, src = %s\n", dest, src);
    memmove(dest, src, 3); // 从 src 复制 3 个字符到 dest
    printf("After memmove dest = %s, src = %s\n", dest, src);

    return(0);
}

（三）、C 库函数 - strcpy() 🍭

C 标准库 - <string.h>

下面是 strcpy() 函数的声明：👇🏻
char *strcpy(char *dest, const char *src)

• strcpy() 函数用于实现把 src 所指向的字符串复制到 dest，该函数返回一个指向最终的目标字符串 dest 的指针。
• dest – 指向用于存储复制内容的目标数组。
• src – 要复制的字符串。

举例1 🌰

#include <stdio.h>  // 包含标准输入输出库，用于使用 printf 等函数
#include <string.h> // 包含字符串处理库，用于使用 memset 和 strcpy 等函数

int main()
{
    char src[40];       // 声明一个长度为 40 的字符数组 src，用于存储源字符串
    char dest[100];     // 声明一个长度为 100 的字符数组 dest，用于存储目标字符串

    memset(dest, '\0', sizeof(dest));  // 使用 memset 函数将 dest 数组的所有元素初始化为 '\0'（即字符串结束符）
    // sizeof(dest) 返回 dest 数组的总大小（100 字节）
    // 这一步确保 dest 数组是一个空字符串

    strcpy(src, "Where there is a will, there is a way."); // 使用 strcpy 函数将字符串 "Where there is a will, there is a way." 复制到 src 数组中
    strcpy(dest, src);                                     // 使用 strcpy 函数将 src 数组中的字符串复制到 dest 数组中

    printf("最终的目标字符串： %s\n", dest);  // 使用 printf 函数输出 dest 数组中的字符串
    // %s 是格式化字符串，表示输出一个字符串

    return 0;  // 返回 0，表示程序正常结束
}

举例2 🌰

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

int main ()
{
    char str1[]="Sample string";
    char str2[40];
    char str3[40];
    strcpy (str2,str1); // 使用 strcpy 函数将 str1 数组中的字符串复制到 str2 数组中
    strcpy (str3,"copy successful"); // 使用 strcpy 函数将字符串 "copy successful" 复制到 str3 数组中
    printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
    return 0;
}

（四）、C 库函数 - memset() 🍭

C 标准库 - <string.h>

下面是 memset() 函数的声明：👇🏻
void *memset(void *str, int c, size_t n)

• memset() 函数将指定的值 c 复制到 str 所指向的内存区域的前 n 个字节中，这可以用于将内存块清零或设置为特定值。该值返回一个指向存储区 str 的指针。
• str – 指向要填充的内存区域的指针。
• c – 要设置的值，通常是一个无符号字符。
• n – 要被设置为该值的字节数。

举例1 🌰

#include <stdio.h>  // 包含标准输入输出库，用于使用 puts 等函数
#include <string.h> // 包含字符串处理库，用于使用 strcpy 和 memset 等函数

int main()
{
   char str[50];  // 声明一个长度为 50 的字符数组 str，用于存储字符串

   strcpy(str, "This is string.h library function");  // 使用 strcpy 函数将字符串 "This is string.h library function" 复制到 str 数组中

   puts(str);  // 使用 puts 函数输出 str 数组中的字符串（自动在末尾添加换行符）

   memset(str, '$', 7);  // 使用 memset 函数将 str 数组的前 7 个字符替换为 '$'
                         // 注意：memset 是按字节操作的，这里将前 7 个字节设置为 '$'

   puts(str);  // 再次使用 puts 函数输出修改后的 str 数组中的字符串

   return 0;  // 返回 0，表示程序正常结束
}

举例2 🌰

#include <stdio.h>  // 包含标准输入输出库，用于使用 printf 等函数
#include <string.h> // 包含字符串处理库，用于使用 memset 函数

int main() {
    char buffer[10];  // 声明一个长度为 10 的字符数组 buffer，用于存储字符串

    // 将 buffer 数组的前5个字节设置为字符 'A'，并添加字符串终止符
    memset(buffer, 'A', 5);  // 使用 memset 函数将 buffer 数组的前5个字节设置为字符 'A'
    buffer[5] = '\0';        // 在第6个位置（索引5）添加字符串终止符 '\0'，确保 buffer 是一个合法的 C 字符串
    printf("Buffer after memset: %s\n", buffer);  // 输出 buffer 数组中的字符串

    // 将 buffer 数组清零，使用 '\0' 替代 0
    memset(buffer, '\0', sizeof(buffer));  // 使用 memset 函数将 buffer 数组的所有字节设置为 '\0'（即清零）
                                           // sizeof(buffer) 返回 buffer 数组的总大小（10 字节）
    printf("Buffer after memset: %s\n", buffer);  // 再次输出 buffer 数组中的字符串（此时为空字符串）

    return 0;  // 返回 0，表示程序正常结束
}

（五）、C 库函数 - strlen() 🍭

C 标准库 - <string.h>

下面是 strlen() 函数的声明：👇🏻
size_t strlen(const char *str)

• strlen() 函数用于实现 计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。该函数返回字符串的长度。
• str – 要计算长度的字符串。

#include <stdio.h>  // 引入标准输入输出库，用于使用 printf 等函数
#include <string.h> // 引入字符串处理库，用于使用 strcpy 和 strlen 等函数

int main() // 主函数，程序入口
{
    char str[50]; // 定义一个字符数组 str，用于存储字符串，最大长度为 49 个字符（最后一个字符是字符串结束符 '\0'）
    int len;      // 定义一个整型变量 len，用于存储字符串的长度

    strcpy(str, "You can get it"); // 使用 strcpy 函数将字符串 "You can get it" 复制到字符数组 str 中

    len = strlen(str); // 使用 strlen 函数计算字符串 str 的长度，并将结果赋值给变量 len

    // 打印字符串及其长度
    // |%s| 表示格式化输出字符串，|%d| 表示格式化输出整数
    printf("|%s| 的长度是 |%d|\n", str, len);

    return 0; // 返回 0，表示程序正常结束
}