字符串和字符串函数

为什么需要专门的「字符串函数」？

上一章你已经知道：C 里没有 string 类型，文本就是 字符数组（character array）。但「知道地址从哪开始」还不够——你还得知道「到哪结束」。

想象一排信箱：每个格子里一个字母，最后一格贴着「到此为止」的标签。如果没有这个标签，邮递员（strlen、strcpy）会一直往后走，直到误闯邻居家的信箱——那就是 未定义行为，轻则乱码，重则程序崩溃。

这一章把 \0 铁律、string.h 四大函数、安全读写的 fgets，以及自己写字符串处理函数的方法讲清楚。搞懂这些，后面结构体、文件 I/O、动态内存都会轻松很多。

字符串表示：可见字符 + 看不见的 \0

空字符（null character） 是 C 字符串的「终点站」。声明：

char animal[10] = "Cat";

编译器放入 4 个字符：C、a、t、\0。数组总长 10，剩余 6 个字节自动填 \0（若未初始化则内容不确定，但字符串有效部分仍到第一个 \0 为止）。

strlen() 从首字符数到 \0 之前；sizeof animal 则是整个数组 10 字节。二者差的那 1（或更多）字节，往往就是结尾的 \0 和未用空间。

#include <stdio.h>
#include <string.h>
 
int main(void) {
    char animal[10] = "Cat";
    printf("strlen = %zu, sizeof = %zu\n",
           strlen(animal), sizeof(animal));
    /* 输出：strlen = 3, sizeof = 10 */
    return 0;
}

手动逐字符赋值时，你必须自己写上 \0，否则不是合法字符串：

char word[4];
word[0] = 'B';
word[1] = 'i';
word[2] = 'g';
word[3] = '\0';   /* 缺一不可 */

string.h 四大基础函数

#include <string.h> 后，最常用的四个函数如下。

strlen：测长度

size_t len = strlen("Hello");  /* 5 */

参数必须是以 \0 结尾的有效字符串。若数组中间没有 \0，strlen 会一直往后读——危险。

strcpy 与 strcat：复制与拼接

strcpy() 把 src 逐字节拷到 dest，包括结尾的 \0：

char dest[20];
strcpy(dest, "Hello");
/* dest 现在是 "Hello" */

strcat() 把 src 接到 dest 已有内容的末尾：

char buf[20] = "Hello";
strcat(buf, ", world!");
/* buf 现在是 "Hello, world!" */

猜一猜：若 dest 只有 8 字节，却 strcpy(dest, "Hello, world!")，会发生什么？用下面 Stepper 看溢出过程。

strcmp：字典序比较

strcmp() 比较的是内容，不是指针地址：

if (strcmp(s1, s2) == 0)
    printf("相同\n");
else if (strcmp(s1, s2) < 0)
    printf("s1 在字典序中更靠前\n");

不要写 if (s1 == s2)——那比较的是两个指针是否指向同一地址，不是字符串内容是否相同。

char 数组 vs char 指针：能不能改？

这是 C 字符串里最容易混淆的一点：

char ar[] = "Hello";   /* 数组：栈上副本，可修改 */
const char *ptr = "Hello"; /* 指针：只读访问字符串字面量 */

ar[0] = 'h' 合法；字符串字面量在 C 中具有 char 数组类型，但任何修改尝试都是未定义行为。字符串字面量 不保证位于某个特定“只读数据段”，所以规则应写成语言契约而不是内存段猜测。用 const char * 接收能让编译器阻止误写；要可改则用 char ar[] 或拥有足够容量的动态对象。

sizeof 也不同：sizeof(ar) 是数组总字节（含 \0）；sizeof(ptr) 是指针变量本身的大小（通常 8 或 4），与字符串长度无关。

函数形参位置的 char s[] 会调整为 char *s，两种声明表示相同参数类型。只读接口应声明 const char *s；否则类型会错误暗示函数可能修改内容。

字符串输入输出：按流读写完整记录

输出：puts 与 fputs

puts(str) 输出字符串并自动换行；fputs(str, stdout) 不自动换行，适合拼到已有输出流：

puts("Hi");           /* Hi + 换行 */
fputs("Hi", stdout);  /* 仅 Hi，无换行 */

输入：用 fgets，别用 gets

fgets() 接受缓冲区大小，但“调用成功”不等于“整行已读完”：

char line[80];
if (fgets(line, sizeof line, stdin) != NULL) {
    char *newline = strchr(line, '\n');
    if (newline != NULL) {
        *newline = '\0';
        printf("完整一行：%s\n", line);
    } else {
        int ch = getchar();
        if (ch == '\n') {
            printf("完整一行：%s\n", line);
        } else if (ch == EOF) {
            if (ferror(stdin))
                fputs("读取失败\n", stderr);
            else
                printf("文件末尾的最后一行：%s\n", line);
        } else {
            while ((ch = getchar()) != '\n' && ch != EOF)
                ;
            fputs("输入行过长\n", stderr);
        }
    }
}

fgets 保留读到的换行；缓冲区填满前没有换行时，要区分“最后一行没有换行”和“当前记录被截断”。gets() 已被 C11 移除，因为接口根本没有容量参数。

自定义字符串函数

理解库函数原理后，可以自己实现简化版——逻辑都是「找 \0」或「逐字节复制直到 \0」。

手写 my_strlen

size_t my_strlen(const char *s) {
    size_t count = 0;
    while (s[count] != '\0')
        count++;
    return count;
}

const char * 表示函数只读字符串，不修改内容——好习惯。

手写 my_strcpy

char *my_strcpy(char *dest, const char *src) {
    char *save = dest;
    while ((*dest++ = *src++) != '\0')
        ;   /* 空循环体：拷贝含 \0 */
    return save;
}

while ((*dest++ = *src++) != '\0') 是经典 C 惯用法：赋值、比较、指针后移一步完成。

它与标准 strcpy 一样要求 dest 容量足够，并要求源与目标对象不重叠；接口没有容量参数，函数自身无法验证这两个前置条件。

场景：读一行并统计单词数（简化）

#include <stdio.h>
#include <ctype.h>
 
int count_words(const char *s) {
    int in_word = 0, count = 0;
    while (*s) {
        if (isspace((unsigned char)*s))
            in_word = 0;
        else if (!in_word) {
            in_word = 1;
            count++;
        }
        s++;
    }
    return count;
}

用 isspace 判断空白，用状态机 in_word 检测「从非空白进入空白」的边界——这就是自定义字符串处理的典型模式。

排序字符串：排序指针而不是复制字符

字符串列表常表示为指针数组。字符串指针排序 可以交给 qsort：

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
 
static int compare_words(const void *lhs, const void *rhs) {
    const char *left = *(const char *const *)lhs;
    const char *right = *(const char *const *)rhs;
    return strcmp(left, right);
}
 
int main(void) {
    const char *words[] = {"pear", "apple", "plum"};
    size_t count = sizeof words / sizeof words[0];
    qsort(words, count, sizeof words[0], compare_words);
    return strcmp(words[0], "apple") != 0;
}

qsort 把“数组元素的地址”传给比较器。这里元素本身是 const char *，所以参数要解释为指向该指针元素的指针，再解引用一次取得字符串。排序只改变 words 中各指针的顺序，不会尝试修改字符串字面量。strcmp 是逐字节字典序，不是面向 locale 的自然语言排序。

命令行参数：argc 与 argv 的边界

宿主环境可以用 main(int argc, char *argv[]) 提供 命令行参数。在宿主提供这些信息时，argc 非负，argv[argc] 是空指针；argv[0] 通常表示程序调用名，但它也可能是空字符串，不能拿来做安全判断。

#include <stdio.h>
 
int main(int argc, char *argv[]) {
    int i;
    if (argc < 2) {
        fprintf(stderr, "usage: %s WORD...\n",
                argc > 0 ? argv[0] : "program");
        return 2;
    }
 
    for (i = 1; i < argc; ++i)
        printf("argv[%d] = %s\n", i, argv[i]);
    return 0;
}

argc 是元素计数，不含末尾空指针；业务参数从 argv[1] 开始。访问前先验证 argc，不能假定用户一定传了某个位置。虽然 C 允许修改 argv 指向的字符串内容，接口设计通常把它们当输入，并在需要长期保存或重排内容时复制到自有存储。

字符串转数字：用 strtol 保留失败原因

atoi 无法把合法的 0 与转换失败区分开，也没有可用的结束位置和可靠范围诊断。strtol() 允许调用方逐层验证：

#include <errno.h>
#include <limits.h>
#include <stdlib.h>
 
static int parse_int(const char *text, int *result) {
    char *end;
    long value;
 
    errno = 0;
    value = strtol(text, &end, 10);
    if (end == text)                  /* 一个数字也没读到 */
        return 0;
    if (*end != '\0')                /* 有未接受的尾随字符 */
        return 0;
    if (errno == ERANGE || value < INT_MIN || value > INT_MAX)
        return 0;
 
    *result = (int)value;
    return 1;
}

调用前把 errno 清零，只在返回后结合结果检查 ERANGE；不能仅看 errno 的旧值。end == text 表示没有转换，*end 检查是否完整消费字符串，再检查 long 到 int 的目标范围。若产品允许尾随空白，应显式用 isspace((unsigned char)*end) 跳过后再要求结束；进制参数用 10 表示十进制，用 0 才会按前缀识别八进制或十六进制。

容易踩的坑

小结

• C 字符串 = 连续 char + 结尾 \0；strlen 数到 \0 前，sizeof 数整个数组
• strcpy / strcat 不检查目标大小；strcmp 返回 0 表示相等
• char ar[] 创建可修改副本；字符串字面量应经 const char 指针只读访问
• fgets 成功后仍要判断换行、文件末尾与截断；输出可用 puts / fputs
• qsort 排字符串指针时交换指针元素，比较器需先解引用到字符串再调用 strcmp
• 命令行参数先检查 argc；字符串转整数用 strtol 检查 endptr、errno 和目标范围
• 自定义函数核心：找 \0、逐字节复制、用 const char * 保护只读参数

char answer[10];
fgets(answer, sizeof answer, stdin);
if (answer == "yes")
    printf("匹配\n");

if (fgets(answer, sizeof answer, stdin) != NULL) {
    answer[strcspn(answer, "\n")] = '\0';
    if (strcmp(answer, "yes") == 0)
        printf("匹配\n");
}

#include <stdio.h>
#include <stddef.h>
 
size_t str_len(const char *s) {
    size_t n = 0;
    while (s[n] != '\0')
        n++;
    return n;
}
 
int main(void) {
    printf("%zu\n", str_len("Cat"));  /* 3 */
    printf("%zu\n", str_len(""));     /* 0 */
    return 0;
}

名词解释

原版目录概念补充核对

以下条目补齐官方目录中容易被示例主线掩盖的概念。它们不重复罗列目录，而是明确每项概念的机制、适用边界和验收证据。

字符串转数字：机制、边界与证据

在《字符串和字符串函数》的官方单元 cpr-11 中，字符串转数字连接本章第 6 组知识约束。学习时要同时说明它接受什么输入、改变什么状态、在何种边界失效；再以本章示例的编译诊断、固定输入输出或失败用例复核结论，不能只记术语名称。