C 语言字符串处理：标准库字符串函数的完全指南

/* 观察字符串在内存中的真实模样 */
#include <stdio.h>
 
int main()
{
    /* 注意：编译器会自动在末尾补一个 '\0'，所以实际占 6 个字节 */
    char str[] = "hello";
 
    printf("sizeof(str) = %zu\n", sizeof(str));   /* 输出 6，包含 '\0' */
    printf("strlen(str) = %zu\n", strlen(str));   /* 输出 5，不含 '\0' */
 
    /* 逐个打印每个字节的 ASCII 码，看看字符串的"真身" */
    int i;
    for (i = 0; i < sizeof(str); i++)
    {
        printf("str[%d] = %d (0x%02X)\n", i, str[i], (unsigned char)str[i]);
    }
    /* 输出：
       str[0] = 104 (0x68)   'h'
       str[1] = 101 (0x65)   'e'
       str[2] = 108 (0x6C)   'l'
       str[3] = 108 (0x6C)   'l'
       str[4] = 111 (0x6F)   'o'
       str[5] = 0   (0x00)   '\0'  ← 字符串的"句号" */
 
    return 0;
}

#include <stdio.h>
#include <ctype.h>
 
int main()
{
    char str[] = "Hello World! 123";
    int i = 0;
    /* 遍历字符串中的每个字符 */
    while (str[i])
    {
        char c = str[i];
        /* 依次判断字符类型并打印对应标签 */
        if (islower(c))
            printf("'%c' 是小写字母\n", c);
        else if (isupper(c))
            printf("'%c' 是大写字母\n", c);
        else if (isdigit(c))
            printf("'%c' 是数字\n", c);
        else if (isspace(c))
            printf("'%c' 是空白字符\n", c);
        else if (ispunct(c))
            printf("'%c' 是标点符号\n", c);
        i++;
    }
    return 0;
}

#include <stdio.h>
#include <ctype.h>
 
int main()
{
    char text[] = "C language, born in 1972! It's still alive.\n";
    int letters = 0, digits = 0, spaces = 0, puncts = 0, others = 0;
    int i = 0;
 
    while (text[i])
    {
        unsigned char c = (unsigned char)text[i];  /* 注意转 unsigned char */
        if (isalpha(c))       letters++;
        else if (isdigit(c))  digits++;
        else if (isspace(c))  spaces++;
        else if (ispunct(c))  puncts++;
        else                  others++;
        i++;
    }
 
    printf("字母: %d, 数字: %d, 空白: %d, 标点: %d, 其他: %d\n",
           letters, digits, spaces, puncts, others);
    return 0;
}

/* 用位掩码模拟字符分类函数的查表思路（示意，非真实实现） */
#include <stdio.h>
 
#define IS_DIGIT (1 << 0)   /* 第 0 位：是数字 */
#define IS_ALPHA (1 << 1)   /* 第 1 位：是字母 */
#define IS_SPACE (1 << 2)   /* 第 2 位：是空白 */
 
/* 256 项的查找表：下标是字符的字节值（0~255），值是属性位集合 */
static const unsigned char table[256] = {0};
 
/* 初始化查找表：把 ASCII 码落在对应区间的字符标上属性位 */
static void init_table(void)
{
    int c;
    for (c = 0; c < 256; c++)
    {
        if (c >= '0' && c <= '9')       table[c] |= IS_DIGIT;
        if ((c >= 'A' && c <= 'Z') ||
            (c >= 'a' && c <= 'z'))     table[c] |= IS_ALPHA;
        if (c == ' ' || c == '\t' ||
            c == '\n' || c == '\v' ||
            c == '\f' || c == '\r')     table[c] |= IS_SPACE;
    }
}
 
/* 三个"分类函数"都只是查表 + 与位掩码 */
int my_isdigit(int c) { return table[(unsigned char)c] & IS_DIGIT; }
int my_isalpha(int c) { return table[(unsigned char)c] & IS_ALPHA; }
int my_isspace(int c) { return table[(unsigned char)c] & IS_SPACE; }
 
int main()
{
    init_table();
    printf("%d %d %d\n", my_isdigit('7'), my_isalpha('g'), my_isspace('\t'));
    /* 输出: 1 1 1 */
    return 0;
}

#include <stdio.h>
#include <ctype.h>
 
int main()
{
    int i = 0;
    char str[] = "Test String.\n";
    char c;
 
    /* 遍历到字符串末尾（'\0'）为止 */
    while (str[i])
    {
        c = str[i];
        /* 如果是小写字母，则转换为大写 */
        if (islower(c))
            c = toupper(c);
        putchar(c);  /* 输出当前字符 */
        i++;
    }
    /* 输出: TEST STRING. */
    return 0;
}

size_t strlen ( const char * str );

char buf[10] = "hello";   /* buf[5..9] 是 '\0' 吗？ */
printf("%zu\n", strlen(buf));  /* 输出 5，因为 buf[5] 恰好是 '\0'（初始化时补的） */

#include <stdio.h>
#include <string.h>
 
int main()
{
    const char *str1 = "abcdef";  /* 6 个字符 */
    const char *str2 = "bbb";     /* 3 个字符 */
 
    /* strlen 返回 size_t（无符号），3 - 6 = 一个巨大的正数 */
    if (strlen(str2) - strlen(str1) > 0)
    {
        printf("str2 > str1\n");  /* 会打印这行！因为无符号溢出 */
    }
    else
    {
        printf("str1 > str2\n");
    }
    return 0;
}

#include <stdio.h>
#include <assert.h>
 
/* 方式1：计数器方式——最直观 */
size_t my_strlen1(const char *str)
{
    size_t count = 0;
    assert(str);          /* 防御性编程：检查空指针 */
    while (*str != '\0')  /* 遇到 '\0' 停止 */
    {
        count++;
        str++;            /* 指针后移 */
    }
    return count;
}
 
/* 方式2：递归方式——不创建临时变量 */
size_t my_strlen2(const char *str)
{
    assert(str);
    if (*str == '\0')
        return 0;
    else
        return 1 + my_strlen2(str + 1);  /* 每次递归处理一个字符 */
}
 
/* 方式3：指针相减——利用同数组内指针差等于元素个数 */
size_t my_strlen3(const char *str)
{
    const char *p = str;
    assert(str);
    while (*p != '\0')
        p++;
    return p - str;  /* 末尾指针 - 起始指针 = 字符个数 */
}
 
int main()
{
    const char *msg = "Hello";
    printf("strlen1: %zu\n", my_strlen1(msg));
    printf("strlen2: %zu\n", my_strlen2(msg));
    printf("strlen3: %zu\n", my_strlen3(msg));
    return 0;
}

char* strcpy ( char * destination, const char * source );

#include <stdio.h>
#include <assert.h>
 
/* 模拟实现 strcpy：
   参数顺序：目标在前，源在后
   功能：将 src 拷贝到 dest，包含 '\0'
   返回值：目标地址，方便链式调用 */
char *my_strcpy(char *dest, const char *src)
{
    char *ret = dest;   /* 保存起始地址用于返回 */
    assert(dest != NULL);
    assert(src != NULL);
 
    /* 这个 while 循环是经典写法：
       先 *dest = *src，再判断赋值结果是否为 '\0' */
    while ((*dest++ = *src++))
    {
        ;  /* 空循环体，所有工作在条件表达式中完成 */
    }
    return ret;
}
 
int main()
{
    char dest[20];
    my_strcpy(dest, "Hello World");
    printf("拷贝结果: %s\n", dest);
    return 0;
}

#include <stdio.h>
#include <string.h>
 
int main()
{
    char small_buf[5];   /* 只有 5 个字节！ */
    const char *long_str = "This string is way too long for the buffer!";
 
    /* 危险！strcpy 不管目标有多大，一路拷贝到 '\0' 为止 */
    strcpy(small_buf, long_str);
 
    /* 程序可能在这里还能"正常"运行，但栈已经被破坏了。
       在某些编译器/平台上会直接崩溃，在其他地方可能默默破坏
       相邻变量——这就是缓冲区溢出漏洞的根源。 */
    printf("small_buf = %s\n", small_buf);
 
    return 0;
}

#include <stdio.h>
#include <assert.h>
 
char *my_strcat(char *dest, const char *src)
{
    char *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
 
    /* 第一步：找到 dest 的 '\0' 位置 */
    while (*dest)
    {
        dest++;
    }
    /* 第二步：从该位置开始拷贝 src，包含 '\0' */
    while ((*dest++ = *src++))
    {
        ;
    }
    return ret;
}
 
int main()
{
    char str[30] = "Hello ";
    my_strcat(str, "World!");
    printf("拼接结果: %s\n", str);
    return 0;
}

#include <stdio.h>
#include <assert.h>
 
int my_strcmp(const char *str1, const char *str2)
{
    assert(str1 != NULL);
    assert(str2 != NULL);
 
    /* 当对应字符相等且不为 '\0' 时继续 */
    while (*str1 == *str2)
    {
        if (*str1 == '\0')   /* 同时到达末尾，说明完全相等 */
            return 0;
        str1++;
        str2++;
    }
    /* 返回第一个不同字符的 ASCII 差值 */
    return *(unsigned char *)str1 - *(unsigned char *)str2;
}
 
int main()
{
    printf("abc vs abc: %d\n", my_strcmp("abc", "abc"));    /* 0 */
    printf("abc vs abd: %d\n", my_strcmp("abc", "abd"));    /* 负数 */
    printf("abd vs abc: %d\n", my_strcmp("abd", "abc"));    /* 正数 */
    return 0;
}

char * strncpy ( char * destination, const char * source, size_t num );

#include <stdio.h>
#include <string.h>
 
int main()
{
    char dest[10];
    /* 将 "HelloWorld123" 的前 5 个字符拷贝到 dest */
    strncpy(dest, "HelloWorld123", 5);
    /* 问题：strncpy 不会自动加 '\0'，如果源长度 >= num */
    dest[5] = '\0';  /* 手动补 '\0'，否则 printf 会越界 */
    printf("strncpy 结果: %s\n", dest);
 
    /* 演示自动补零：源长度(5) < num(10) */
    char dest2[10] = {'A','A','A','A','A','A','A','A','A','A'};
    strncpy(dest2, "Hi", 5);
    /* dest2 前2个字符是 'H','i'，后面3个都是 '\0' */
    printf("自动补零演示: %c %c %d %d\n",
           dest2[0], dest2[1], dest2[2], dest2[3]);  /* 输出 H i 0 0 */
    return 0;
}

#include <stdio.h>
#include <assert.h>
 
char *my_strncpy(char *dest, const char *src, size_t num)
{
    char *ret = dest;
    size_t i;
    assert(dest != NULL);
    assert(src != NULL);
 
    for (i = 0; i < num; i++)
    {
        /* 如果源还没结束，拷贝源字符；否则填充 '\0' */
        if (*src)
            *dest++ = *src++;
        else
            *dest++ = '\0';
    }
    return ret;
}
 
int main()
{
    char buf[10];
    my_strncpy(buf, "Hi", 5);
    printf("前4个字节的值: %d %d %d %d\n",
           (unsigned char)buf[0],
           (unsigned char)buf[1],
           (unsigned char)buf[2],
           (unsigned char)buf[3]);  /* 输出 72 105 0 0 */
    return 0;
}

#include <stdio.h>
#include <string.h>
 
int main()
{
    char str1[20];  /* 确保足够大 */
    char str2[20];
 
    strcpy(str1, "To be ");
    strcpy(str2, "or not to be");
 
    /* 从 str2 追加 6 个字符到 str1 末尾，并自动加 '\0' */
    strncat(str1, str2, 6);
    printf("%s\n", str1);  /* 输出: To be or not */
 
    return 0;
}

#include <stdio.h>
#include <string.h>
 
int main()
{
    /* 判断是否以 "https://" 开头 */
    const char *url = "https://example.com";
    if (strncmp(url, "https://", 8) == 0)
        printf("是 HTTPS 链接\n");
    else if (strncmp(url, "http://", 7) == 0)
        printf("是 HTTP 链接\n");
    else
        printf("未知协议\n");
 
    /* 只比较前 3 个字符：不看后面的差异 */
    printf("strncmp(\"abcxyz\", \"abcdef\", 3) = %d\n",
           strncmp("abcxyz", "abcdef", 3));  /* 输出 0，前3个相同 */
    printf("strncmp(\"abcxyz\", \"abcdef\", 4) = %d\n",
           strncmp("abcxyz", "abcdef", 4));  /* 非0，第4个不同 */
 
    return 0;
}

#include <stdio.h>
#include <string.h>
 
int main()
{
    const char *s = "hello world, hello C";
 
    /* strchr：找第一个 'l' */
    char *p1 = strchr(s, 'l');
    if (p1) printf("strchr 第一个 'l' 位置: %s\n", p1);  /* llo world... */
 
    /* strrchr：找最后一个 'l' */
    char *p2 = strrchr(s, 'l');
    if (p2) printf("strrchr 最后一个 'l' 位置: %s\n", p2);  /* llo C */
 
    /* strstr：找子串 "hello" 第二次出现的位置 */
    char *p3 = strstr(s + 1, "hello");  /* 从第二个字符开始找 */
    if (p3) printf("strstr 第二次 'hello': %s\n", p3);  /* hello C */
 
    /* strpbrk：找 "wo" 中任意字符第一次出现 */
    char *p4 = strpbrk(s, "wo");
    if (p4) printf("strpbrk 找到 'w' 或 'o': %s\n", p4);  /* world... */
 
    /* strspn：s 开头连续由 "helo "（注意含空格）组成的长度
       "hello " 共 6 个字符都在集合里（第 6 个是空格），
       第 7 个字符 'w' 不在集合，所以结果是 6 */
    size_t n1 = strspn(s, "helo ");
    printf("strspn(\"%s\", \"helo \") = %zu\n", s, n1);  /* 6 (hello ) */
 
    /* strcspn：s 开头连续不含 "wd" 的长度
       "hello " 6 个字符都不含 'w'/'d'，第 7 个字符 'w' 命中，所以结果是 6 */
    size_t n2 = strcspn(s, "wd");
    printf("strcspn(\"%s\", \"wd\") = %zu\n", s, n2);  /* 6 (hello_ ) */
 
    return 0;
}

#include <stdio.h>
 
/* strchr 的模拟实现：从左往右找字符 */
char *my_strchr(const char *s, int c)
{
    /* 注意：c 以 int 传入，但要与 unsigned char 比较 */
    while (*s != '\0' && *s != (char)c)
    {
        s++;
    }
    /* 如果 *s == c 且 c != '\0'，返回 s；
       如果 c == '\0'，上面循环在 *s=='\0' 时退出，同样返回 s（指向末尾） */
    if (*s == (char)c)
        return (char *)s;
    return NULL;
}
 
int main()
{
    char *p = my_strchr("Hello", 'e');
    if (p) printf("找到: %s\n", p);  /* ello */
    return 0;
}

#include <stdio.h>
 
char *my_strstr(const char *str1, const char *str2)
{
    char *cp = (char *)str1;
    char *s1, *s2;
 
    /* 如果查找的是空字符串，直接返回 str1 */
    if (!*str2)
        return (char *)str1;
 
    /* 外层循环：以 str1 的每个字符为起点尝试匹配 */
    while (*cp)
    {
        s1 = cp;
        s2 = (char *)str2;
        /* 内层循环：逐一比较当前起点的后续字符 */
        while (*s1 && *s2 && !(*s1 - *s2))
        {
            s1++;
            s2++;
        }
        /* 如果 s2 走到了 '\0'，说明完全匹配 */
        if (!*s2)
            return cp;
        cp++;  /* 当前起点不匹配，后移一位 */
    }
    return NULL;
}
 
int main()
{
    char *result = my_strstr("hello world", "wor");
    if (result)
        printf("找到子串: %s\n", result);  /* 输出: world */
    else
        printf("未找到\n");
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
/* 大小写不敏感的 strstr 实现（非标准函数，自己写的） */
char *stristr(const char *haystack, const char *needle)
{
    const char *h, *n;
    if (!*needle) return (char *)haystack;
 
    while (*haystack)
    {
        h = haystack;
        n = needle;
        /* 使用 tolower 忽略大小写差异 */
        while (*h && *n && tolower((unsigned char)*h) == tolower((unsigned char)*n))
        {
            h++;
            n++;
        }
        if (!*n) return (char *)haystack;
        haystack++;
    }
    return NULL;
}
 
int main()
{
    char *result = stristr("Hello WORLD", "world");
    if (result)
        printf("大小写不敏感查找结果: %s\n", result);  /* WORLD */
    return 0;
}

#include <stdio.h>
#include <string.h>
 
int main()
{
    char arr[] = "192.168.6.111";
    char *sep = ".";    /* 分隔符集合 */
    char *str = NULL;
 
    /* 第一次调用传 arr，后续传 NULL */
    for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    {
        printf("%s\n", str);  /* 依次输出 192、168、6、111 */
    }
    /* 此时 arr 已被修改：'192\0168\06\0111' */
    return 0;
}

/* 简化版 strtok 模拟（演示"静态变量保存状态"的核心机制） */
char *my_strtok(char *str, const char *delim)
{
    static char *save;      /* 静态变量！所有调用共享 */
    char *token_start;
 
    if (str != NULL)
        save = str;         /* 首次调用：从 str 开始 */
    if (save == NULL || *save == '\0')
        return NULL;        /* 没有剩余内容了 */
 
    /* 跳过前导分隔符 */
    while (*save && strchr(delim, *save))
        save++;
    if (*save == '\0')
        return NULL;
 
    token_start = save;     /* 记录 token 起点 */
 
    /* 找下一个分隔符，替换为 '\0'，更新 save */
    while (*save && !strchr(delim, *save))
        save++;
    if (*save)              /* 遇到了分隔符 */
    {
        *save = '\0';       /* 用 '\0' 截断 */
        save++;             /* save 指向下一个 token 的开头 */
    }
    return token_start;
}

#include <stdio.h>
#include <string.h>
#include <errno.h>
 
int main()
{
    /* 打印前 10 个错误码对应的描述信息 */
    int i;
    for (i = 0; i <= 10; i++)
    {
        printf("错误码 %d: %s\n", i, strerror(i));
    }
 
    /* 实际使用场景：打开不存在的文件 */
    FILE *pFile = fopen("不存在的文件.txt", "r");
    if (pFile == NULL)
    {
        /* 方式一：手动拼接 strerror */
        printf("方式一 - 错误: %s\n", strerror(errno));
 
        /* 方式二：perror 直接打印 */
        perror("方式二 - 错误");
 
        /* 两种方式输出内容等价 */
    }
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
/* 去除字符串两端的空白字符 */
char *trim(char *str)
{
    char *end;
 
    /* 跳过开头的空白字符 */
    while (isspace((unsigned char)*str)) str++;
 
    if (*str == 0)  /* 全是空白字符 */
        return str;
 
    /* 从末尾向前跳过空白字符 */
    end = str + strlen(str) - 1;
    while (end > str && isspace((unsigned char)*end)) end--;
 
    /* 在最后一个非空白字符后写入 '\0' */
    *(end + 1) = '\0';
 
    return str;
}
 
int main()
{
    char str[] = "   hello world   ";
    printf("trim 前: [%s]\n", str);
    printf("trim 后: [%s]\n", trim(str));
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
/* 解析一行 "key = value" 配置，输出 key 和 value（去除空白） */
int parse_line(char *line)
{
    char *eq;      /* '=' 的位置 */
    char *key;
    char *value;
 
    /* 跳过开头的空白（也跳过空行） */
    while (isspace((unsigned char)*line)) line++;
    if (*line == '\0' || *line == '#')   /* 空行或注释 */
        return 0;
 
    /* 找 '=' 号 */
    eq = strchr(line, '=');
    if (eq == NULL)
    {
        printf("格式错误（缺少 = ）: %s\n", line);
        return -1;
    }
 
    /* 把 '=' 替换为 '\0'，把一行切成两段 */
    *eq = '\0';
    key = trim(line);
    value = trim(eq + 1);
 
    if (*key == '\0' || *value == '\0')
    {
        printf("格式错误（key 或 value 为空）: %s\n", line);
        return -1;
    }
 
    printf("key = \"%s\", value = \"%s\"\n", key, value);
    return 1;
}
 
int main()
{
    /* 模拟一个配置文件的内容（每行用 \n 分隔） */
    char config[] =
        "# 服务器配置\n"
        "host = 192.168.1.1\n"
        "port = 8080\n"
        "   \n"
        "timeout = 30\n";
 
    /* 用 strtok 逐行切分，再逐行解析 */
    char *line = strtok(config, "\n");
    while (line != NULL)
    {
        parse_line(line);
        line = strtok(NULL, "\n");
    }
    return 0;
}

#include <stdio.h>
#include <string.h>
 
/* 原地反转字符串（会修改原串） */
void reverse_str(char *s)
{
    if (s == NULL)          /* 防御：空指针 */
        return;
    char *left = s;
    char *right = s + strlen(s) - 1;  /* 指向最后一个有效字符 */
 
    while (left < right)    /* 相遇或交错即停 */
    {
        char tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
 
int main()
{
    char s[] = "Hello World";
    reverse_str(s);
    printf("%s\n", s);      /* 输出: dlroW olleH */
    return 0;
}

#include <stdio.h>
#include <ctype.h>
 
/* 统计单词个数：单词 = 非空白字符的连续序列 */
int count_words(const char *s)
{
    int count = 0;
    int in_word = 0;          /* 当前是否已在一个单词内部 */
 
    while (*s)
    {
        if (isspace((unsigned char)*s))
        {
            in_word = 0;      /* 遇空白，单词结束 */
        }
        else if (!in_word)
        {
            in_word = 1;      /* 非空白且刚进入新单词 */
            count++;
        }
        s++;
    }
    return count;
}
 
int main()
{
    const char *s = "  hello   world, C   language  ";
    printf("%d\n", count_words(s));  /* 输出: 4 */
    return 0;
}