C 的字符串有哪些问题

C 字符串没有保存自己的长度，而是选择在以一个特殊的值 NUL 标记在字符串的尾部。这样做带来的比较直观的问题便是：需要获得字符串长度时必须遍历字符串直到找到空字符。也就是说，strlen 函数的时间复杂度是 O(n)，n 是字符串的长度。每调用一次 strlen 都需要从头到尾遍历一次字符串。下面的代码的时间复杂度可是 O(n^2)：

for (int i = 0; i < strlen(stryy); i++)
{
    ;
}

由于经常需要知道字符串尾部的位置，对 strlen 的调用是十分频繁的，这是一种很浪费的行为。

另一个问题在于，我们是没有办法来判断一个 C 字符串是不是合法的。【7】中这样写到：

对于给定的任何 C 字符串，都不可能验证它是否有效：

• 以 NUL 结尾的 C 字符串是有效的
• 任何处理无效 C 字符串的循环都是无限的（或者造成缓冲区溢出）
• C 字符串没有确定的长度，检查是否有效的唯一方式就是通过遍历来观察是否终止

所以，不通过有限的循环就不可能验证 C 字符串的有效性。

也就是说，我们不能以遍历为手段编写一个能够判断字符串是否有效的函数，因为无限长的有效字符串和无效的字符串对于遍历操作的结果是一样的，即不会结束的循环。

如果已知字符串长度在一定范围内，可以使用固定长度的字节数组来用于存储字符串。但是需要动态改变字符串长度时，就必须处理内存块的分配，改变大小和释放，对字符串的手动内存管理会带来不小的心智负担，很容易出现缓冲区溢出等其他内存管理问题。

char * gets(char *);

想要安全的使用这个函数的话，你需要清楚地知道你将会读入多少字符，但是只有在读取完毕后，你才知道你读入了多少字符。也就是说该函数以有限的缓冲区空间来面对不定数量的输入，这是非常危险的。如果读入的字符数量超过了缓冲区长度，将会导致缓冲区溢出。

在 C11 中，这个函数被废除了，使用更加安全的 gets_s 代替。

scanf 族函数也存在这个问题，但是可以在格式化字符串中使用数字来限制字符的读入个数，就像这样

char a[32] = {0};
scanf("%32s", a);

char * fgets(char *str, int n, FILE *stream);

相比于 gets 函数来说，fgets 安全了很多，可以通过提供最大缓冲区参数给 fgets 来限制读入字符的最大长度。这里提到 fgets 主要是一些容易忽略的小坑。

函数原型中的 n 是缓冲区的长度，而不是字符串的最大长度。fgets 会把换行符也放入 str 中，如果输入的字符串长度大于等于 n - 1，则换行符会被舍弃，就像这样：

char a[5];
fgets(a, 5, stdin);
for (int i = 0; i < 5; i++) printf("%d ", a[i]);


//输入 abcdef，会得到 97 98 99 100 0，可见其中不存在换行符 10

另一个问题我是从【8】中了解到的，原文如下：

fgets has the unusual semantic of ignoring '\0's that occur before '\n's are consumed.

翻译过来的意思就是：fgets 具有不同寻常的性质，它会忽略出现在 '\n' 之前的所有空字符。

对这句话作何理解呢？用下面的代码做个实验吧：

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    FILE * fp = NULL;

    if ((fp = fopen("1.txt", "w")) == NULL) exit(1);

    char a[10] = { '\0' };
    a[0] = a[1] = 'y';
    for (int i = 0; i < 10; i++) fputc(a[i], fp);
    fputc('\n', fp);
    fclose(fp);

    if ((fp = fopen("1.txt", "r")) == NULL) exit(2);

    char b[20];
    for (int i = 0; i < 20; i++) b[i] = 1;

    fgets(b, 20, fp);

    for (int i = 0; i < 20; i++) printf("%d ", b[i]);

    fclose(fp);

    return 0;
}

上述代码的输出结果是： 121 121 0 0 0 0 0 0 0 0 10 0 1 1 1 1 1 1 1 1 。也就是说 fgets 读取了在换行符之前的所有空字符，并没有对空字符进一步处理。这样对使用者带来的问题是，他根本就不知道读入了多少个空字符，他只知道字符串正常截止了。

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

这个函数的功能是将 source 字符串连接到 destination 字符串。让我们看看下面的代码：

char a[20] = "Hello";
strcat(a, a);
puts(a);

你认为这段代码的输出是什么，是 HelloHello 吗？然而结果是直接崩溃。VS 调试器给出的结果是：0xC0000005: Access violation writing location 0x00F40000.

在【2】的 strcat 子页面中有这样的函数描述：

source：C string to be appended. This should not overlap destination.

它的意思是：源字符串不应该与目标字符串相重叠。

上面的示例代码中，我的 source 和 destination 字符串重叠了，这样会导致什么问题呢？首先，函数执行时是需要保证源字符串不变的，因为需要使用到它的值。但是，由于目标字符串的值是需要改变的，又由于源字符串和目标字符串是同一字符串，所以它既需要改变，又不能被改变，这会带来一个矛盾。内存重叠是一种未定义行为，会带来不可预知的后果。此处的解释部分参考了【9】

话又说回来，我使用长度小于 4 的字符串来运行上面的代码的话，是可以得到正确的结果的，我的运行环境是 VS2019，关于这个问题我也无从下手，就先留在这里吧。

上面 strcat 面对的问题是一个普遍的问题，那就是内存重叠。

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

这里的 num 是源字符串要复制到目的字符串的字符数量。

关于这个函数，这里提一个小点，那就是：

Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.

No null-character is implicitly appended at the end of destination if source is longer than num. Thus, in this case, destination shall not be considered a null terminated C string (reading it as such would overflow).

翻译过来的意思就是：函数会将源字符串的前 num 个字符拷贝给目标字符串。如果在 num 个字符被拷贝之前就到了源字符串的结尾，那么会向目标字符串继续复制空字符，直到 num 个字符被复制。如果源字符串的长度大于等于 num，那么目标的结尾就不会有空字符。

具体来看的话，可以使用以下的代码来对比不同 num 时函数的行为：

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

int main(void)
{
    char a[100];
    memset(a, 1, 100);
    strncpy(a, "Hello", 4);
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", a[i]);
    }
    memset(a, 1, 100);
    strncpy(a, "Hello", 5);
    putchar('\n');
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", a[i]);
    }
    memset(a, 1, 100);
    strncpy(a, "Hello", 6);
    putchar('\n');
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", a[i]);
    }
}

运行结果为：

72 101 108 108 1 1 1 1 1 1
72 101 108 108 111 1 1 1 1 1
72 101 108 108 111 0 1 1 1 1

可以看到，只有 num 为 6 时，目标的结尾才会有空字符。

char * strtok ( char * str, const char * delimiters );

这里我认为有必要详细地介绍一下这个函数的工作过程。以下内容来自【2】的 strtok 子页面。

对该函数的一系列调用可以将 str 分成一个个 token，token 之间原本由 delimiters 中的字符分开。

在第一次调用时，这个函数接受一个字符串 str，str 的第一个字符会被作为扫描开始地点。在随后的调用中，函数的 str 参数应该为 NULL，该函数使用上一个 token 的结尾来作为新的 token 的开头，并进行扫描。

为判断 token 的开头和结尾，该函数会从开始位置扫描，找到第一个不是分隔字符的字符来作为 token 的开头。随后开始寻找分隔符，找到的地方就成了 token 的结尾。当找到空字符时，扫描也会结束。

token 的结尾会被自动替换为一个空字符，函数返回 token 开头的地址。

一旦 strtok 遇到了空字符，随后对它的调用都会返回空指针。

上一个 token 被找到的位置会被 strtok 函数在内部保存，并用于下一次调用。

关于它的具体使用，这里我举一个简单的例子：

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

int main(void)
{
    char a[] = "hello , abcde , wocoa, - hhhhh";
    char* p;

    p = strtok(a, ", -");
    while (p)
    {
        printf("%s\n", p);
        p = strtok(NULL, ", -");
    }
    for (int i = 0; i < sizeof(a); i++)
    {
        printf("(%c)(%d)", a[i], a[i]);
    }
}

运行结果为：

hello

abcde

wocoa

hhhhh

(h)(104)(e)(101)(l)(108)(l)(108)(o)(111)( )(0)(,)(44)( )(32)(a)(97)(b)(98)(c)(99)(d)(100)(e)(101)( )(0)(,)(44)( )(32)(w)(119)(o)(111)(c)(99)(o)(111)(a)(97)( )(0)( )(32)(-)(45)( )(32)(h)(104)(h)(104)(h)(104)(h)(104)(h)(104)( )(0)

可以看到，其中token 结尾处的分隔符被替换为了空字符。

实际上，我几乎没有用到过这个函数，关于它的问题，我是通过搜索引擎得到的，下面我会对某个回答【11】进行一些翻译：

通过编程来解决问题的基础技术就是构造抽象来解决子问题，然后将对子问题的解法进行组合来解决更大的问题。

strtok 的工作方式严重违背了上述规则：它是一个不可靠的糟糕抽象，因为它的组合能力很差。

tokenization 的根本问题是：给定一个字符串，要求得到从某个位置开始的 token 的结尾（given a position in a string, give the position of the end of the token beginning at that position）。如果 strtok 仅仅这样做的话，它还是很不错的。这将会是一个清晰的抽象，它将不会依赖于隐层的全局状态，它也将不会改变自己的输入字符串。

要想看到 strtok的局限性，想象一下我们要 tokenize 一种语言，我们希望以空格作为分隔符，但是我们不希望在 "" 之内的内容被 tokenized。这种情况下，我们就希望对被引号的内容使用不同的规则，并在滞后继续使用空格作为分隔符。但是 strtok 做不到这一点，它只能处理简单的 tokenization 工作。

词法分析器（Lexer）写起来不难。写就对了！

如果你写的是不可变（immutable）的 Lexer，那就更好一些。不可变的词法分析器是一个小对象，它包含对被分析的字符串的索引，词法分析器当前位置和词法分析器所需要的状态。要提取一个 token，你可以调用 "next token" 方法，你得到 token 和一个新的词法分析器。新的词法分析器又可以继续用在下一个 token 上。你可以按照你的喜好注销掉之前的词法分析器。

由于本人的英文水平有限，上面的翻译难免会有不通顺的地方，你可以直接阅读原文来获得更好的体验。

结合上面我写的示例代码和上面的一段翻译，我们可以把 strtok 这个函数的特性总结一下：

• 会改变被解析的字符串的值
• 需要存储字符串的位置，供下一次调用使用
• 需要多次调用来完成对一个字符串的 tokenize
• tokenize 的能力很 trivial

这里可以看出，它是无法同时处理两个字符串的，如果一个字符串处理了一半，再使用另一个字符串作为 str 参数的话，内部存储位置的指针会被重新初始化，进而把原先字符串的处理进度丢失掉。可以使用函数 strtok_r 来解决这个问题，它接受一个指针参数，用来保存当前的字符串处理位置。

由于每调用一次都会改变内部变量的状态，它也不是可重入的。从而也不是线程安全的。不过，MS 的 strtok 是线程安全的，它会为每一个线程准备一个变量来存储当前的位置。引文如下：

Each function uses a thread-local static variable for parsing the string into tokens. Therefore, multiple threads can simultaneously call these functions without undesirable effects.【13】