strlen 数到 '\0' 停,strcpy 把 '\0' 一起搬过去,strcmp 在第一个不同的字符处给出正负,strtok 把分隔符本身改写成 '\0'。字符串这一组函数都围绕同一个字节展开:它既是长度的终点,也是拷贝的终点,还是比较的终点。字符分类函数单独住在 ctype.h,处理单个字符,和终止符无关。

ctype.h 里的 11 个判断函数

图注:这张表把字符分类函数和各自的判定条件列全了。看 isgraph 和 isprint 两行,前者不含空格,后者包含空格

iscntrl 判控制字符,isspace 判空白(空格、\f、\n、\r、\t、\v),isdigit 判十进制数字,isxdigit 判十六进制数字(含 af、AF),islower、isupper、isalpha、isalnum、ispunct、isgraph、isprint 各管一类。容易混的只有 isgraph 和 isprint:图形字符不含空格,可打印字符包含空格。

它们的原型都长成 int isxxx(int c);。参数声明成 int 是为了能接收 EOF(通常是 -1),返回值用非 0 表示真,具体是几由实现决定。所以判断时写 if (islower(c)),不要写 if (islower(c) == 1)。

课件的小写转大写练习,按标准写法改成这样:

#include <ctype.h>
#include <stdio.h>
 
int main(void)
{
    char str[] = "Test String.\n";
    int i = 0;
 
    while (str[i] != '\0')
    {
        unsigned char c = (unsigned char)str[i];
 
        if (islower(c))
            c = (unsigned char)toupper(c);
        putchar(c);
        i++;
    }
    return 0;
}

toupper 把参数里的小写字母转成大写,tolower 把大写转成小写,方向相反。课件正文写“有了转换函数,就可以直接使用 tolower 函数”,紧跟着的示例调用的却是 toupper。这两句对不上:示例做的是小写转大写,该用 toupper;照正文抄成 tolower,条件里的小写字母转完还是原样,大写字母也碰不到,输出仍然是 Test String.。

课件练习里的 c -= 32 能跑,是因为 ASCII 里大小写字母刚好差 32。这个 32 来自编码表,不是 C 语言的规则,换一种字符集就不成立。用 toupper 更稳。

还有一条前提写在手册里:传给这些函数的参数,值必须能表示成 unsigned char,或者等于 EOF。char 在多数平台上默认有符号,字节大于 127 时传进去就是负数,行为未定义。纯 ASCII 输入不会触发,但库函数不承诺兜底,养成先转 unsigned char 的习惯。

strlen 的三种写法,和一个无符号减法

原型是 size_t strlen(const char *str);。规则三条:字符串以 '\0' 结束;返回值是 '\0' 前面的字符个数,不含 '\0';返回类型是 size_t,无符号。传进来的数组如果没有终止符,函数会一路读到越界,长度算出来是偶然值。

三种模拟实现:

#include <assert.h>
#include <stddef.h>
 
/* 计数器 */
size_t my_strlen1(const char *s)
{
    size_t count = 0;
 
    assert(s != NULL);
    while (*s != '\0')
    {
        count++;
        s++;
    }
    return count;
}
 
/* 递归,不建计数器 */
size_t my_strlen2(const char *s)
{
    assert(s != NULL);
    if (*s == '\0')
        return 0;
    return 1 + my_strlen2(s + 1);
}
 
/* 指针相减 */
size_t my_strlen3(const char *s)
{
    const char *p = s;
 
    assert(s != NULL);
    while (*p != '\0')
        p++;
    return (size_t)(p - s);
}

三种写法都用了 assert,所以要包含 assert.h。课件方式 3 的参数名是 s,assert 里写的却是 str,这个标识符在函数里不存在,打开断言会直接编译失败。返回类型也写成了 int,字符串长度超过 INT_MAX 时会被截断;标准原型是 size_t。递归版在超长字符串上会耗尽栈,计数版最稳。

size_t 是无符号,两个长度相减就会回绕:

#include <stdio.h>
#include <string.h>
 
int main(void)
{
    const char *str1 = "abcdef";   /* 6 */
    const char *str2 = "bbb";      /* 3 */
 
    if (strlen(str2) - strlen(str1) > 0)
        printf("str2 更长\n");
    else
        printf("str1 更长\n");
 
    return 0;
}

3 - 6 在 size_t 上不会得到 -3,结果回绕成 SIZE_MAX - 2,跟 0 相比永远更大,屏幕上打印“str2 更长”,而实际上 str1 更长。课件用这段代码说明“返回值是 size_t,无符号,易错”,指的就是这件事。

比较长度不要先减,写 if (strlen(str2) > strlen(str1))。倒序遍历同理,for (size_t i = strlen(s) - 1; i >= 0; i--) 在空串时下标越界,非空时 i >= 0 恒真,减到 0 再减一次又回绕。安全写法是先判断再减:

#include <stdio.h>
#include <string.h>
 
void print_reverse(const char *s)
{
    size_t n = strlen(s);
 
    while (n > 0)
    {
        n--;
        putchar(s[n]);
    }
}

strcpy 与 memcpy:谁能越过那个 0

char *strcpy(char *destination, const char *source);。四条约束:源串必须 '\0' 结尾;'\0' 会被复制过去;目标空间必须放得下整个源串;目标必须可写。

#include <assert.h>
#include <stddef.h>
 
char *my_strcpy(char *dest, const char *src)
{
    char *ret = dest;
 
    assert(dest != NULL);
    assert(src != NULL);
 
    while ((*dest++ = *src++))
    {
    }
    return ret;
}

*dest++ = *src++ 的表达式值是刚写入的字符。非 0 就继续;'\0' 先被写进去,再让条件为假,循环正好停在那里,终止符一定跟着走。函数不知道 dest 还剩多少字节,长度只能由调用者保证。

这里就是 strcpy 和 memcpy 的分界:

对比项strcpymemcpy
停止条件写完 '\0' 就停拷满 num 个字节
长度来源源串自己调用者给
数据中间有 '\0'后面的内容丢掉原样搬完
源与目标重叠未定义未定义

中间可能夹 0 的数据(图片、结构体、含 0 的编码)只能用 memcpy;纯文本串两边都靠 '\0',用 strcpy 省事,容量风险照旧。strcpy 写超了不报错,栈上相邻字节碰巧没用,看起来“正常”,这是缓冲区溢出最常见的入口。

strncpy 限制了拷贝个数,边界更绕。源串短于 num 时,剩下的位置补 0,直到写满 num 个;源串长度等于或大于 num 时,一个 '\0' 都不补:

#include <string.h>
 
int main(void)
{
    char a[10];
 
    strncpy(a, "HelloWorld123", 5);   /* 前 5 个字节是 Hello,没有终止符 */
    a[5] = '\0';                      /* 自己补 */
    return 0;
}

所以 strncpy 不是“安全的 strcpy”,它只限制从源里拿几个字节,目标容量照样不检查。

strcat 与 strncat:先找到串尾,再决定写多少

char *strcat(char *destination, const char *source); 从 dest 的 '\0' 处开始覆盖,写完新内容再补一个 '\0'。约束和 strcpy 类似,多一条:dest 自己必须有 '\0',否则找不到追加起点。

#include <assert.h>
#include <stddef.h>
 
char *my_strcat(char *dest, const char *src)
{
    char *ret = dest;
 
    assert(dest != NULL);
    assert(src != NULL);
 
    while (*dest != '\0')
        dest++;
 
    while ((*dest++ = *src++))
    {
    }
    return ret;
}

调用前需要的空间是 strlen(dest) + strlen(src) + 1,最后一个 1 是新终止符。

自己给自己追加(strcat(s, s))在标准里是未定义行为。看流程就明白:dest 先走到原串末尾,src 从开头读;写到末尾之后,写的位置正好是源还要继续读的位置,原来的 '\0' 被覆盖,循环再也停不下来。

strncat 最多从源里拿 num 个字符,然后无条件补一个 '\0',最坏写入量是 num + 1:

#include <stdio.h>
#include <string.h>
 
int main(void)
{
    char str1[20] = "To be ";
    char str2[20] = "or not to be";
 
    strncat(str1, str2, 6);
    printf("%s\n", str1);   /* To be or not */
 
    return 0;
}

注意它和 strncpy 的差别:strncat 一定补终止符,strncpy 不一定。

strcmp 与 strncmp:只有符号有意义

int strcmp(const char *str1, const char *str2); 从第一个字符开始逐对比较,遇到不同或遇到 '\0' 停止。标准只规定三种结果:大于 0、等于 0、小于 0。具体返回几由实现决定,strcmp(a, b) == 1 不可移植,判相等只能写 == 0。

比较按 unsigned char 进行。课件模拟实现的最后一行是 return *str1 - *str2;。char 若为有符号,大于 127 的字节会先符号扩展成负数:0x80 和 'a'(97)比较,按无符号是 128 对 97,前者大;按有符号是 -128 对 97,结论反了。改成先转 unsigned char:

#include <assert.h>
 
int my_strcmp(const char *s1, const char *s2)
{
    assert(s1 != NULL);
    assert(s2 != NULL);
 
    while (*s1 == *s2)
    {
        if (*s1 == '\0')
            return 0;
        s1++;
        s2++;
    }
    return (int)((unsigned char)*s1 - (unsigned char)*s2);
}

strncmp(str1, str2, num) 最多比 num 个字符,中途不同就提前结束,全相同返回 0。它常用来判前缀:

#include <string.h>
 
int is_https(const char *url)
{
    return strncmp(url, "https://", 8) == 0;
}

课件把 strncmp 描述成“最多比较 num 个字母”。比的是字符或字节,数字、标点一样参与。

strstr 找子串,strtok 就地切分

char *strstr(const char *str1, const char *str2); 返回 str2 在 str1 中第一次出现的地址,找不到返回 NULL。匹配不包含终止符,遇到 '\0' 就结束;str2 是空串时返回 str1 本身。

#include <stddef.h>
 
char *my_strstr(const char *haystack, const char *needle)
{
    const char *h = haystack;
 
    if (*needle == '\0')
        return (char *)haystack;
 
    while (*h != '\0')
    {
        const char *a = h;
        const char *b = needle;
 
        while (*a != '\0' && *b != '\0' && *a == *b)
        {
            a++;
            b++;
        }
        if (*b == '\0')
            return (char *)h;
        h++;
    }
    return NULL;
}

课件示例用它做原地替换:

#include <stdio.h>
#include <string.h>
 
int main(void)
{
    char str[] = "This is a simple string";
    char *pch = strstr(str, "simple");
 
    if (pch != NULL)
        strncpy(pch, "sample", 6);
 
    printf("%s\n", str);
    return 0;
}

simple 和 sample 都是 6 个字符,原地覆盖不会碰掉后面的 '\0'。换成更长的替换词就要重新算空间。

strtok 的接口在这一组里最特别:

#include <stdio.h>
#include <string.h>
 
int main(void)
{
    char arr[] = "192.168.6.111";
    const char *sep = ".";
    char *tok = NULL;
 
    for (tok = strtok(arr, sep); tok != NULL; tok = strtok(NULL, sep))
        printf("%s\n", tok);
 
    return 0;
}

sep 是分隔符的集合,不是一整个分隔串,",;" 里的逗号和分号都算。函数做三件事:跳过前导分隔符;把遇到的下一个分隔符改写成 '\0';把内部位置存进静态变量,下次传 NULL 时接着往下找。没有更多标记时返回 NULL。

由此带出几条限制:原串会被改坏,只能传可写数组,不能传字符串字面量;连续的分隔符被当成一个,CSV 里的空字段会消失;内部状态是全局的,多线程或嵌套调用会互相覆盖进度,需要重入时用 POSIX 的 strtok_r 或 Windows 的 strtok_s。

strerror 与 perror:把 errno 翻译成一句话

char *strerror(int errnum); 返回错误码对应的说明字符串地址。错误码定义在 errno.h,运行库用 errno 记录最近一次失败:程序启动时是 0,标准库函数出错时被写入对应值。成功调用不会把它清零,所以要先确认函数真的失败了,再去读 errno。

#include <errno.h>
#include <stdio.h>
#include <string.h>
 
int main(void)
{
    FILE *fp = fopen("unexist.ent", "r");
 
    if (fp == NULL)
        printf("打开失败:%s\n", strerror(errno));
 
    return 0;
}

课件还打印了 0 到 10 的错误码,输出从 No error、Operation not permitted 一直到 No child processes。这段代码的价值在于看清编号和文字的对应,具体文案随 C 运行库变化,不能拿它做字符串比较。

strerror 返回的指针指向运行库内部的一块缓冲区,下一次调用可能把它覆盖,要长期保存就自己复制一份。

perror 把上面两步合成一步:打印参数里的字符串,接着一个冒号和空格,再打印错误信息。

#include <stdio.h>
 
int main(void)
{
    FILE *fp = fopen("unexist.ent", "r");
 
    if (fp == NULL)
        perror("打开失败");
 
    return 0;
}

输出形如 打开失败: No such file or directory。strerror 返回字符串,perror 直接输出,两者都依赖 errno 当时的值,中间不要插入别的库调用。

这一组函数都在回答同一个问题:这段字节到哪里算结束。strlen 用 '\0' 找终点,strcpy、strcat 把终点一起搬,strcmp 在终点前比大小,strstr 在终点前找模式,strtok 把终点插在分隔符的位置。终点之外的空间,它们一概不管。