【C语言】字符函数、字符串函数，内存函数

上期回顾: 【C语言】指针（超详细！！一篇文章搞定！！！）
个人主页：C_GUIQU
归属专栏：C语言

前言

各位小伙伴大家好！上期小编给大家讲解了C语言中的指针，接下来我们讲解一下字符函数、字符串函数，内存函数！

1. 字符函数

字符函数的头文件为ctype.h
具体用法参考: https://legacy.cplusplus.com/reference/cctype/

1.1 字符分类函数

一张图概括

1.2 字符转换函数

1.2.1 tolower（将大写字母转化为小写字母）

tolower 函数是C语言标准库中的一个函数，用于将大写字母转换为小写字母。这个函数位于 <ctype.h> 头文件中。
以下是 tolower 函数的基本用法：

int tolower(int c);

• c：要转换的字符。
• 返回值：转换后的小写字母，如果 c 已经是小写字母，则返回 c 本身。

示例代码：

#include <stdio.h>
#include <ctype.h>
int main()
{
    char ch = 'H';
    char lowerCh = tolower(ch);
    printf("原始字符: %c\n", ch);
    printf("转换后的小写字符: %c\n", lowerCh);
    return 0;
}

在这个示例中，我们首先声明了一个字符变量 ch，并初始化为大写字母 ‘H’。然后，我们使用 tolower 函数将 ch 转换为小写字母，并将转换后的字符存储在变量 lowerCh 中。最后，我们打印出原始字符和转换后的小写字符。

1.2.2 toupper（将小写字母转化为大写字母）

toupper 函数是C语言标准库中的一个函数，用于将小写字母转换为大写字母。这个函数位于 <ctype.h> 头文件中。
以下是 toupper 函数的基本用法：

int toupper(int c);

• c：要转换的字符。
• 返回值：转换后的大写字母，如果 c 已经是大写字母，则返回 c 本身。

示例代码：

#include <stdio.h>
#include <ctype.h>
int main()
{
    char ch = 'h';
    char upperCh = toupper(ch);
    printf("原始字符: %c\n", ch);
    printf("转换后的大写字符: %c\n", upperCh);
    return 0;
}

在这个示例中，我们首先声明了一个字符变量 ch，并初始化为小写字母 ‘h’。然后，我们使用 toupper 函数将 ch 转换为大写字母，并将转换后的字符存储在变量 upperCh 中。最后，我们打印出原始字符和转换后的大写字符。

2. 字符串函数

字符串的输入函数和输出函数头文件均为stdio.h
其它的字符串函数头文件一般为string.h

2.1 求字符串长度函数 strlen

在C语言中，strlen 函数用于计算字符串的长度，不包括字符串末尾的 \0 字符。这个函数位于 <string.h> 头文件中。
以下是 strlen 函数的基本用法：

size_t strlen(const char *s);

• s：指向字符串的指针。
• 返回值：字符串的长度，以字节为单位，不包括字符串末尾的 \0 字符。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    const char *str = "Hello, World!";
    size_t length = strlen(str);
    printf("字符串长度: %zu\n", length);
    return 0;
}

在这个示例中，我们首先声明了一个指向字符串 "Hello, World!" 的指针 str。然后，我们使用 strlen 函数计算字符串的长度，并将结果存储在变量 length 中。最后，我们打印出字符串的长度。

2.2 字符串输入函数 gets()&fgets()

2.2.1 gets()

在C语言中，gets 函数是一个用于读取字符串的标准库函数，它位于 <stdio.h> 头文件中。gets 函数允许用户从标准输入（通常是键盘）读取一行字符串，直到遇到换行符或输入缓冲区满为止。
以下是 gets 函数的基本用法：

char *gets(char *s);

• s：指向字符串的指针，用于存储读取的字符串。
• 返回值：gets 函数返回指向 s 的指针。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    char str[100];
    printf("请输入一段文本: ");
    gets(str);
    printf("您输入的文本是: %s\n", str);
    return 0;
}

在这个示例中，我们首先声明了一个足够大的字符数组 str，用于存储用户输入的文本。然后，我们使用 printf 函数提示用户输入文本。用户输入文本后，gets 函数将读取输入并存储在 str 数组中。最后，我们使用 printf 函数打印出用户输入的文本。

【注意】gets 函数在安全性方面存在问题，因为它不会检查输入缓冲区的大小，这可能导致缓冲区溢出。因此，在现代编程实践中，通常建议使用 fgets 函数代替 gets，后者可以指定输入缓冲区的大小，从而防止缓冲区溢出。

下面介绍fgets()

2.2.2 fgets()

在C语言中，fgets 函数是一个用于从文件或标准输入读取字符串的标准库函数，它位于 <stdio.h> 头文件中。fgets 函数允许用户从文件或标准输入读取一行字符串，直到遇到换行符或输入缓冲区满为止。
以下是 fgets 函数的基本用法：

char *fgets(char *s, int size, FILE *stream);

• s：指向字符串的指针，用于存储读取的字符串。
• size：指定字符串缓冲区的大小，即最多可以读取的字符数。
• stream：指向 FILE 对象的指针，指定读取的文件或标准输入。
• 返回值：fgets 函数返回指向 s 的指针。如果读取成功，它将包含读取的字符串和结束符 \0。如果读取失败（例如，到达文件末尾或发生错误），它将返回 NULL。

示例代码：

#include <stdio.h>
int main()
{
    char str[100];
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    if (fgets(str, sizeof(str), file) == NULL) {
        perror("Error reading file");
        fclose(file);
        return 1;
    }
    printf("读取的文本是: %s\n", str);
    fclose(file);
    return 0;
}

在这个示例中，我们首先声明了一个足够大的字符数组 str，用于存储从文件中读取的文本。然后，我们使用 fopen 函数打开一个名为 example.txt 的文件，并检查文件是否成功打开。如果文件打开成功，我们使用 fgets 函数从文件中读取一行文本，并将其存储在 str 数组中。最后，我们使用 fclose 函数关闭文件，并打印出读取的文本。

【注意】fgets 函数在读取字符串时会包括换行符，所以如果你想要在打印时去除换行符，你需要将字符串的末尾的换行符删除。

2.3 字符串输出函数 puts()

在C语言中，puts 函数是一个用于输出字符串的标准库函数，它位于 <stdio.h> 头文件中。puts 函数会将字符串输出到标准输出（通常是显示器）上，并在字符串末尾自动添加一个换行符。
以下是 puts 函数的基本用法：

int puts(const char *s);

• s：指向字符串的指针。
• 返回值：puts 函数返回一个非负值，表示成功输出的字符数。

示例代码：

#include <stdio.h>
int main()
{
    const char *str = "Hello, World!";
    puts(str);
    return 0;
}

在这个示例中，我们首先声明了一个指向字符串 "Hello, World!" 的指针 str。然后，我们使用 puts 函数将字符串输出到标准输出上。最后，程序返回一个值，表示成功输出的字符数。

【注意】puts 函数在输出字符串时会在字符串末尾添加一个换行符，因此如果你不需要换行符，你可以使用 printf 函数来输出字符串，如下所示：

#include <stdio.h>
int main()
{
    const char *str = "Hello, World!";
    printf("%s\n", str);
    return 0;
}

在这个示例中，我们使用 printf 函数输出字符串，并在字符串末尾添加了一个换行符。

2.4 长度不受限制的字符串函数

2.4.1 字符串复制函数 strcpy

在C语言中，strcpy 函数是一个用于复制字符串的标准库函数，它位于 <string.h> 头文件中。strcpy 函数会将源字符串复制到目标字符串中，并在目标字符串末尾添加一个 \0 字符。
以下是 strcpy 函数的基本用法：

char *strcpy(char *dest, const char *src);

• dest：目标字符串的指针，复制完成后将包含源字符串的内容。
• src：源字符串的指针。
• 返回值：strcpy 函数返回 dest 指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char dest[50];
    const char *src = "Hello, World!";
    strcpy(dest, src);
    printf("复制后的字符串是: %s\n", dest);
    return 0;
}

在这个示例中，我们首先声明了一个足够大的字符数组 dest，用于存储复制后的字符串。然后，我们声明了一个指向源字符串 "Hello, World!" 的指针 src。接着，我们使用 strcpy 函数将 src 指向的字符串复制到 dest 数组中。最后，我们使用 printf 函数打印出复制后的字符串。

【注意】strcpy 函数在复制字符串时不会检查目标字符串缓冲区的大小，这可能导致缓冲区溢出。因此，在实际编程中，建议使用 strncpy 函数来指定目标缓冲区的大小，以防止缓冲区溢出。

2.4.2 字符串连接函数 strcat

在C语言中，strcat 函数是一个用于连接两个字符串的标准库函数，它位于 <string.h> 头文件中。strcat 函数会将源字符串连接到目标字符串的末尾，并在目标字符串末尾添加一个 \0 字符。
以下是 strcat 函数的基本用法：

char *strcat(char *dest, const char *src);

• dest：目标字符串的指针，连接完成后将包含源字符串的内容。
• src：源字符串的指针。
• 返回值：strcat 函数返回 dest 指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char dest[50] = "Hello, ";
    const char *src = "World!";
    strcat(dest, src);
    printf("连接后的字符串是: %s\n", dest);
    return 0;
}

在这个示例中，我们首先声明了一个足够大的字符数组 dest，用于存储连接后的字符串。然后，我们声明了一个指向源字符串 "World!" 的指针 src。接着，我们使用 strcat 函数将 src 指向的字符串连接到 dest 数组的末尾。最后，我们使用 printf 函数打印出连接后的字符串。

【注意】strcat 函数在连接字符串时不会检查目标字符串缓冲区的大小，这可能导致缓冲区溢出。因此，在实际编程中，建议使用 strncat 函数来指定目标缓冲区的大小，以防止缓冲区溢出。

2.4.3 字符串比较函数 strcmp

在C语言中，strcmp 函数是一个用于比较两个字符串的标准库函数，它位于 <string.h> 头文件中。strcmp 函数会比较两个字符串，并返回一个整数，以指示它们之间的相对顺序。
以下是 strcmp 函数的基本用法：

int strcmp(const char *s1, const char *s2);

• s1 和 s2：指向要比较的字符串的指针。
• 返回值：strcmp 函数返回一个整数。如果 s1 和 s2 相等，返回值为 0。如果 s1 小于 s2，返回值小于 0。如果 s1 大于 s2，返回值大于 0。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    const char *str1 = "Hello, World!";
    const char *str2 = "hello, world!";
    int result = strcmp(str1, str2);
    printf("比较结果是: %d\n", result);
    return 0;
}

在这个示例中，我们首先声明了两个指向字符串 "Hello, World!" 和 "hello, world!" 的指针 str1 和 str2。然后，我们使用 strcmp 函数比较这两个字符串，并存储比较结果在变量 result 中。最后，我们使用 printf 函数打印出比较结果。

【注意】strcmp 函数比较字符串时是区分大小写的。如果需要不区分大小写地进行比较，可以使用 strncmp 函数，或者在比较前先将字符串转换为统一的大小写。

2.5 长度受限制的字符串函数

2.5.1 strncpy

在C语言中，strncpy 函数是一个标准库函数，它用于将源字符串复制到目标字符串中，直到复制了指定数量的字符或者遇到源字符串中的空字符 \0。这个函数通常位于 <string.h> 头文件中。
以下是 strncpy 函数的基本用法：

char *strncpy(char *dest, const char *src, size_t n);

• dest：目标字符串，即要复制字符串的地址。
• src：源字符串，即要复制的字符串的地址。
• n：指定要复制的字符数量。如果 n 为 0，则不会复制任何字符。
• 返回值：strncpy 函数返回 dest 指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char dest[20];
    const char *src = "Hello, World!";
    strncpy(dest, src, 5); // 复制前 5个字符
    printf("dest = %s\n", dest); // 输出: dest = Hello 
    return 0;
}

在这个示例中，strncpy 函数将源字符串 "Hello, World!" 的前5个字符复制到目标字符串 dest 中，结果为 "Hello"。
strncpy 函数的一个特点是，如果目标字符串 dest 的长度小于源字符串 src 的长度，它会在目标字符串的末尾添加空字符 \0，以确保目标字符串是一个有效的字符串。如果目标字符串的长度大于源字符串的长度，它将仅复制源字符串中的字符，并在末尾添加足够的空字符 \0 来填充目标字符串。

2.5.2 strncat

在C语言中，strncat 函数是一个标准库函数，它用于将源字符串的一部分连接到目标字符串的末尾。这个函数通常位于 <string.h> 头文件中。
以下是 strncat 函数的基本用法：

char *strncat(char *dest, const char *src, size_t n);

• dest：目标字符串，即要连接字符串的地址。
• src：源字符串，即要连接到目标字符串末尾的字符串的地址。
• n：指定要连接的字符数量。如果 n 为 0，则不会连接任何字符。
• 返回值：strncat 函数返回 dest 指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char dest[20] = "Hello, ";
    const char *src = "World!";
    strncat(dest, src, 5); // 连接前 5个字符
    printf("dest = %s\n", dest); // 输出: dest = Hello, World
    return 0;
}

在这个示例中，strncat 函数将源字符串 "World!" 的前5个字符连接到目标字符串 dest 的末尾，结果为 "Hello, World"。
strncat 函数的一个特点是，如果目标字符串 dest 的长度小于源字符串 src 的长度，它会在目标字符串的末尾添加空字符 \0，以确保目标字符串是一个有效的字符串。如果目标字符串的长度大于源字符串的长度，它将仅连接源字符串中的字符，并在末尾添加足够的空字符 \0 来填充目标字符串。

2.5.3 strncmp

在C语言中，strncmp 函数是一个标准库函数，它用于比较两个字符串，只比较指定数量的字符。这个函数通常位于 <string.h> 头文件中。
以下是 strncmp 函数的基本用法：

int strncmp(const char *s1, const char *s2, size_t n);

• s1 和 s2：指向要比较的字符串的指针。
• n：指定要比较的字符数量。如果 n 为 0，则比较会停止，并返回 0。
• 返回值：strncmp 函数返回一个整数。如果 s1 和 s2 相等，返回值为 0。如果 s1 小于 s2，返回值小于 0。如果 s1 大于 s2，返回值大于 0。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    const char *str1 = "Hello, World!";
    const char *str2 = "hello, world!";
    int result = strncmp(str1, str2, 5); // 比较前 5个字符
    printf("比较结果是: %d\n", result);
    return 0;
}

在这个示例中，strncmp 函数比较字符串 "Hello, World!" 和 "hello, world!" 的前5个字符，结果为 0，因为它们的前5个字符是相同的。
strncmp 函数的一个特点是，它只比较指定数量的字符，而不是整个字符串。这有助于避免缓冲区溢出和提高比较的效率。如果需要比较整个字符串，可以使用 strcmp 函数。

2.6 字符串查找函数 strstr

在C语言中，strstr 函数是一个标准库函数，用于在另一个字符串中查找子字符串。这个函数通常位于 <string.h> 头文件中。
以下是 strstr 函数的基本用法：

char *strstr(const char *haystack, const char *needle);

• haystack：指向主字符串的指针。
• needle：指向要查找的子字符串的指针。
• 返回值：strstr 函数返回一个指针，指向 haystack 中第一次出现 needle 子字符串的位置。如果 needle 子字符串在 haystack 中不存在，则返回 NULL。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    const char *str = "Hello, World!";
    const char *substr = "World";
    const char *found = strstr(str, substr);
    if (found != NULL) {
        printf("子字符串 \"%s\" 在字符串 \"%s\" 中找到，位置为：%s\n",
               substr, str, found);
    } else {
        printf("子字符串 \"%s\" 在字符串 \"%s\" 中未找到。\n",
               substr, str);
    }
    return 0;
}

在这个示例中，strstr 函数在字符串 "Hello, World!" 中查找子字符串 "World"。如果找到，它会返回子字符串在主字符串中首次出现的起始地址。如果没有找到，它将返回 NULL。

2.7 字符串分割函数 strtok

在C语言中，strtok 函数是一个标准库函数，用于分割字符串。这个函数通常位于 <string.h> 头文件中。
以下是 strtok 函数的基本用法：

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

• str：指向要分割的字符串的指针。
• delim：指向分隔符字符串的指针。
• 返回值：strtok 函数返回一个指针，指向分割后的第一个单词。如果 str 为 NULL，strtok 函数将开始一个新的分割序列，并使用 delim 指定的分隔符字符串作为分割点。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    const char *str = "Hello, World! This is a test.";
    const char *delim = " ,.!";
    char *token;
    token = strtok(str, delim);
    while (token != NULL) {
        printf("%s\n", token);
        token = strtok(NULL, delim);
    }
    return 0;
}

在这个示例中，strtok 函数使用分隔符字符串 ",.!" 来分割字符串 "Hello, World! This is a test."。它将字符串分割成单词，并在每次迭代中返回下一个单词的起始地址。当没有更多的单词可以返回时，token 变为 NULL，循环结束。

2.8 错误处理函数 strerror

在C语言中，strerror 函数是一个标准库函数，用于将错误代码转换为相应的错误消息字符串。这个函数通常位于 <string.h> 头文件中。
以下是 strerror 函数的基本用法：

char *strerror(int errnum);

• errnum：一个整数，表示要转换的错误代码。
• 返回值：strerror 函数返回一个指向错误消息字符串的指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    int err = errno; // 获取当前的错误代码
    char *error_message = strerror(err); // 转换错误代码为错误消息
    printf("错误代码: %d, 错误消息: %s\n", err, error_message);
    return 0;
}

在这个示例中，strerror 函数将当前的错误代码 errno 转换为相应的错误消息字符串，并将其存储在 error_message 变量中。最后，程序打印出错误代码和对应的错误消息。

【注意】strerror 函数返回的字符串是静态分配的，因此每次调用 strerror 函数时，返回的指针可能指向不同的内存地址。如果你需要在多个函数之间共享错误消息，你应该在调用 strerror 函数后复制字符串，或者使用 strerror_r 函数，它可以将错误消息复制到一个用户提供的缓冲区中。

3. 内存函数

3.1 memcpy

在C语言中，memcpy 函数是一个标准库函数，用于将一个内存块的内容复制到另一个内存块中。这个函数通常位于 <string.h> 头文件中。
以下是 memcpy 函数的基本用法：

void *memcpy(void *dest, const void *src, size_t n);

• dest：目标内存块的地址，即将要复制到的内存地址。
• src：源内存块的地址，即要复制的内存地址。
• n：指定要复制的字节数量。
• 返回值：memcpy 函数返回 dest 指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char src[10] = "Hello";
    char dest[10] = "World";
    memcpy(dest, src, 5); // 复制前 5个字符
    printf("dest = %s\n", dest); // 输出: dest = HelloWorld
    return 0;
}

在这个示例中，memcpy 函数将源字符串 "Hello" 的前5个字符复制到目标字符串 "World" 中，结果为 "HelloWorld"。
memcpy 函数的一个特点是，它不会检查目标内存块的大小，这可能导致缓冲区溢出。因此，在实际编程中，你需要确保目标内存块有足够的空间来容纳源内存块的内容和额外的字节。

3.2 memmove

在C语言中，memmove 函数是一个标准库函数，用于将一个内存块的内容复制到另一个内存块中。这个函数通常位于 <string.h> 头文件中。
以下是 memmove 函数的基本用法：

void *memmove(void *dest, const void *src, size_t n);

• dest：目标内存块的地址，即将要复制到的内存地址。
• src：源内存块的地址，即要复制的内存地址。
• n：指定要复制的字节数量。
• 返回值：memmove 函数返回 dest 指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char src[10] = "Hello";
    char dest[10] = "World";
    memmove(dest, src, 5); // 复制前 5个字符
    printf("dest = %s\n", dest); // 输出: dest = HelloWorld
    return 0;
}

在这个示例中，memmove 函数将源字符串 "Hello" 的前5个字符复制到目标字符串 "World" 中，结果为 "HelloWorld"。
memmove 函数的一个特点是，它可以安全地处理重叠内存区域。与 memcpy 不同，memmove 函数会从目标内存块的末尾开始复制，以避免在复制过程中覆盖源内存块或目标内存块中的数据。因此，memmove 函数在处理重叠内存时更加安全。

3.3 memset

在C语言中，memset 函数是一个标准库函数，用于将内存块中的所有字节设置为指定的值。这个函数通常位于 <string.h> 头文件中。
以下是 memset 函数的基本用法：

void *memset(void *s, int c, size_t n);

• s：指向要设置的内存块的指针。
• c：指定要设置的字节值。这个值通常是一个整数，但在C语言中，任何整数都可以作为字节值。
• n：指定要设置的字节数量。
• 返回值：memset 函数返回 s 指针。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char str[10] = "Hello, World!";
    memset(str, 'X', 5); // 将前5个字符设置为 'X'
    printf("修改后的字符串是: %s\n", str); // 输出: XXXXX, World!
    return 0;
}

在这个示例中，memset 函数将字符串 "Hello, World!" 的前5个字符设置为字符 ‘X’，结果为 "XXXXX, World!"。
memset 函数通常用于初始化内存块或清除内存块中的数据。它是一个非常基础和常用的函数，用于确保内存块中的数据不会包含未知的值，从而避免潜在的安全风险。

3.4 memcmp

在C语言中，memcmp 函数是一个标准库函数，用于比较两个内存块的内容，并返回一个整数以表示它们之间的比较结果。这个函数通常位于 <string.h> 头文件中。
以下是 memcmp 函数的基本用法：

int memcmp(const void *s1, const void *s2, size_t n);

• s1 和 s2：指向要比较的两个内存块的指针。
• n：指定要比较的字节数量。如果 n 为 0，则比较会停止，并返回 0。
• 返回值：memcmp 函数返回一个整数。如果两个内存块相等，返回值为 0。如果 s1 小于 s2（即按照字节顺序在 s2 之前），返回值小于 0。如果 s1 大于 s2（即按照字节顺序在 s2 之后），返回值大于 0。

示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    const char *str1 = "Hello, World!";
    const char *str2 = "hello, world!";
    int result = memcmp(str1, str2, 5); // 比较前 5个字节
    printf("比较结果是: %d\n", result);
    return 0;
}

在这个示例中，memcmp 函数比较两个内存块，每个块包含5个字节。由于 str1 和 str2 的前5个字节是相同的，所以返回值为 0。
memcmp 函数的一个特点是，它只比较指定数量的字节，而不是整个内存块。这有助于避免不必要的比较，提高比较的效率。如果需要比较整个内存块，可以使用 strcmp 函数。

结语

以上就是小编对字符函数、字符串函数，内存函数的详细讲解。
如果觉得小编讲的还可以，还请一键三连。互三必回！
持续更新中~！