~C.库函数的介绍~

今天给小伙伴们带来的是C语言中一些库函数的详细介绍，使用方法以及使用时的一些注意事项@

函数介绍

1.strlen函数

strlen 是 C 语言标准库中的一个函数，用于计算以空字符 \0 结尾的字符串的长度。strlen 函数返回字符串中的字符数量，不包括最后的空字符。

函数原型如下：

size_t strlen(const char *str);

示例代码

以下是使用 strlen 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strlen 函数的头文件

int main()
 {
    char str[] = "Hello, World!";
    size_t length = strlen(str);

    printf("The length of the string is: %zu\n", length);

    return 0;
}

注意事项

1. strlen 函数只计算直到遇到第一个空字符 \0 的字符数量。如果字符串中间有 \0，strlen 会在遇到第一个 \0 时停止计数。

2. strlen 函数不检查字符串是否有效或是否越界，因此使用时需要确保传入的字符串是有效的 C 字符串（以 \0 结尾）。

3. strlen 函数返回的是 size_t 类型，这是一个无符号整数类型，通常用于表示大小和计数。

4. 在多字节字符集中（如 UTF-16 或 UTF-32），strlen 仍然只计算字节长度，而不是字符数量。对于宽字符字符串，应使用 wcslen 函数。

5. strlen 函数的时间复杂度是 O(n)，其中 n 是字符串的长度，因为它需要遍历整个字符串直到找到空字符。

2.strcpy 函数

strcpy 是 C 语言标准库中的一个函数，用于复制字符串。它将源字符串（包括 \0 结尾符）复制到目标字符串中。strcpy 函数不检查目标数组的大小，因此如果目标数组不够大，可能会导致缓冲区溢出，这是潜在的安全风险。

函数原型如下：

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

//dest：指向目标字符串的指针，该函数会将 src 字符串的内容复制到 dest 指向的内存位置。
//src：指向源字符串的指针，strcpy 函数会复制该字符串的内容，包括空字符 \0。

返回值

strcpy 函数返回目标字符串 dest 的指针。

示例代码

以下是使用 strcpy 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strcpy 函数的头文件

int main() {
    char src[] = "Hello, World!";
    char dest[20]; // 确保目标数组足够大以存储 src 字符串

    strcpy(dest, src);

    printf("Copied string: %s\n", dest);

    return 0;
}

注意事项

1. 缓冲区溢出：使用 strcpy 时必须确保目标数组有足够的空间来存储源字符串，包括空字符 \0。

2. 安全性：由于 strcpy 不执行任何边界检查，使用时需要特别小心。在可能的情况下，推荐使用 strncpy 或其他更安全的字符串操作函数。

3. 重叠字符串：如果源字符串和目标字符串有重叠，strcpy 的行为是未定义的。在这种情况下，应使用 memmove 函数。

4. 空终止符：strcpy 会复制源字符串的空终止符 \0，确保目标字符串正确地以 \0 结尾。

5. 返回值：strcpy 返回目标字符串的指针，这可以用于链式操作，例如 strcpy(dest, src1); strcat(dest, src2);。

3.strcat函数

strcat 是 C 语言标准库中的一个函数，用于将两个字符串连接起来。它将源字符串（不包括空字符 \0）追加到目标字符串的末尾，并在连接后的字符串末尾添加空字符 \0。

函数原型如下：

char *strcat(char *dest, const char *src);
//dest：指向目标字符串的指针，该函数会将 src 字符串的内容追加到 dest 指向的内存位置。
//src：指向源字符串的指针，strcat 函数会复制该字符串的内容（不包括空字符 \0）

返回值

strcat 函数返回目标字符串 dest 的指针。

示例代码

以下是使用 strcat 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strcat 函数的头文件

int main() 
{
    char dest[20] = "Hello, ";
    char src[] = "World!";

    strcat(dest, src);

    printf("Concatenated string: %s\n", dest);

    return 0;
}

注意事项

1. 缓冲区溢出：使用 strcat 时必须确保目标数组有足够的空间来存储两个字符串的连接结果，包括空字符 \0。

2. 安全性：由于 strcat 不执行任何边界检查，使用时需要特别小心。在可能的情况下，推荐使用 strncat 或其他更安全的字符串操作函数。

3. 重叠字符串：如果源字符串和目标字符串有重叠，strcat 的行为是未定义的。在这种情况下，应使用 memmove 函数。

4. 空终止符：strcat 会保留目标字符串的空终止符 \0，并在连接后的字符串末尾添加新的空终止符。

5. 返回值：strcat 返回目标字符串的指针，这可以用于链式操作。

6. 性能：strcat 需要从目标字符串的开头扫描到末尾以找到第一个空字符，这可能会增加执行时间。如果已知目标字符串的长度，使用 strncat 可能更高效。

4.strcmp函数

strcmp 是 C 语言标准库中的一个函数，用于比较两个字符串。它按照字典顺序比较两个字符串，直到找到不相等的字符或遇到空字符 \0。

函数原型如下：

int strcmp(const char *str1, const char *str2);
//str1：指向第一个字符串的指针。
//str2：指向第二个字符串的指针。

返回值

strcmp 函数返回一个整数值，表示两个字符串的比较结果：

• 如果 str1 小于 str2，则返回值小于 0。
• 如果 str1 等于 str2，则返回值等于 0。
• 如果 str1 大于 str2，则返回值大于 0。

示例代码

以下是使用 strcmp 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strcmp 函数的头文件

int main() {
    char str1[] = "Hello";
    char str2[] = "World";
    char str3[] = "Hello";

    int result1 = strcmp(str1, str2); // 比较 str1 和 str2
    int result2 = strcmp(str1, str3); // 比较 str1 和 str3

    if (result1 < 0) {
        printf("'%s' is less than '%s'\n", str1, str2);
    } else if (result1 > 0) {
        printf("'%s' is greater than '%s'\n", str1, str2);
    } else {
        printf("'%s' is equal to '%s'\n", str1, str2);
    }

    if (result2 == 0) {
        printf("'%s' is equal to '%s'\n", str1, str3);
    }

    return 0;
}

注意事项

1. 大小写敏感：strcmp 是大小写敏感的，所以 "Hello" 和 "hello" 会被认为是不相等的。

2. 非空终止字符串：strcmp 函数假设输入的字符串是以空字符 \0 结尾的。如果字符串不是以 \0 结尾的，strcmp 可能会读取内存中未定义的区域。

3. 性能：strcmp 函数在找到第一个不相等的字符或空字符时停止比较，所以它的时间复杂度是 O(n)，其中 n 是字符串的长度。

4. 使用场景：strcmp 常用于字符串比较、排序和搜索等场景。

5. 返回值：strcmp 的返回值可以用于条件语句和逻辑运算，因为它返回的是一个整数。

5.strncmp函数

strncmp 是 C 语言标准库中的一个函数，用于比较两个字符串的前 n 个字符。它在比较时考虑了字符串的字典顺序，并且可以限制比较的字符数，这使得它在处理字符串时更加灵活。

函数原型如下：

int strncmp(const char *str1, const char *str2, size_t n);
//str1：指向第一个字符串的指针。
//str2：指向第二个字符串的指针。
//n：要比较的最大字符数。

示例代码

以下是使用 strncmp 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strncmp 函数的头文件

int main() {
    const char str1[] = "Hello";
    const char str2[] = "World";
    const char str3[] = "Hello";

    int result1 = strncmp(str1, str2, sizeof(str1) - 1); // 比较 str1 和 str2 的前 5 个字符
    int result2 = strncmp(str1, str3, sizeof(str1) - 1); // 比较 str1 和 str3 的前 5 个字符

    if (result1 < 0) {
        printf("'%s' is less than '%s'\n", str1, str2);
    } else if (result1 > 0) {
        printf("'%s' is greater than '%s'\n", str1, str2);
    } else {
        printf("'%s' is equal to '%s'\n", str1, str2);
    }

    if (result2 == 0) {
        printf("'%s' is equal to '%s'\n", str1, str3);
    }

    return 0;
}

注意事项

1. 大小写敏感：strncmp 是大小写敏感的，所以 "Hello" 和 "hello" 会被认为是不相等的。

2. 空终止符：strncmp 会在到达空字符 \0 或比较了 n 个字符后停止，以先到者为准。

3. 性能：strncmp 的时间复杂度是 O(n)，其中 n 是要比较的字符数。

4. 返回值：strncmp 的返回值可以用于条件语句和逻辑运算，因为它返回的是一个整数。

5. 安全性：在使用 strncmp 比较字符串时，确保不要超过字符串的实际长度，以避免未定义行为。

strncmp 函数是处理字符串比较任务的有用工具，尤其是在需要比较字符串的一部分或限制比较长度时。它提供了一种安全的方式来避免超出字符串边界的风险。

6.strncpy函数

strncpy 是 C 语言标准库中的一个函数，用于将字符串从源内存地址复制到目标内存地址，同时允许指定最大复制的字符数。与 strcpy 不同，strncpy 可以防止缓冲区溢出，因为它限制了复制的字符数。

函数原型如下：

char *strncpy(char *dest, const char *src, size_t n);
//dest：指向目标字符串的指针，数据将被复制到这个位置。
//src：指向源字符串的指针，数据将从这个位置复制。
//n：最大复制的字符数。

返回值

strncpy 函数返回一个指向目标字符串 dest 的指针。

示例代码

以下是使用 strncpy 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strncpy 函数的头文件

int main() 
{
    char src[] = "Hello, World!";
    char dest[20]; // 确保目标数组足够大以存储 src 字符串

    // 使用 strncpy 复制字符串，最多复制 13 个字符
    strncpy(dest, src, 13);

    // 确保目标字符串以空字符结尾
    dest[13] = '\0';

    printf("Copied string: %s\n", dest);

    return 0;
}

注意事项

1. 空终止符：strncpy 不会自动添加空终止符 \0 如果源字符串的长度小于 n。因此，在使用 strncpy 后，通常需要手动设置空终止符。

2. 剩余字符：如果源字符串的长度大于或等于 n，strncpy 将不会复制空终止符，并且目标字符串可能不以空字符结尾。

3. 安全性：尽管 strncpy 可以减少缓冲区溢出的风险，但它仍然需要谨慎使用，特别是在确定目标数组大小和手动设置空终止符时。

4. 返回值：strncpy 返回目标字符串的指针，这可以用于链式操作。

5. 性能：strncpy 的时间复杂度是 O(n)，其中 n 是要复制的字符数。

strncpy 是一个有用的函数，用于在复制字符串时控制最大字符数，但需要确保目标字符串正确地以空字符结尾。在可能的情况下，使用 strlcpy 或其他更安全的字符串操作函数可能是更好的选择。

7.strncat函数

strncat 是 C 语言标准库中的一个函数，用于将源字符串（不包括空字符 \0）追加到目标字符串的末尾，并在连接后的字符串末尾添加空字符 \0。与 strcat 不同，strncat 允许指定最大追加的字符数，这有助于防止缓冲区溢出。

函数原型如下：

char *strncat(char *dest, const char *src, size_t n);
//dest：指向目标字符串的指针，源字符串将被追加到这个位置。
//src：指向源字符串的指针，字符串将从这个位置复制。
//n：最大追加的字符数。

返回值

strncat 函数返回一个指向目标字符串 dest 的指针。

示例代码

以下是使用 strncat 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strncat 函数的头文件

int main() 
{
    char dest[20] = "Hello, ";
    char src[] = "World!";
    size_t n = 6; // 追加的字符数

    // 使用 strncat 追加字符串，最多追加 6 个字符
    strncat(dest, src, n);

    printf("Concatenated string: %s\n", dest);

    return 0;
}

注意事项

1. 缓冲区溢出：尽管 strncat 允许指定最大追加的字符数，但仍需确保目标数组有足够的空间来存储两个字符串的连接结果，包括空字符 \0。

2. 空终止符：strncat 会在连接后的字符串末尾添加空字符 \0，但如果 n 大于或等于 src 的长度，strncat 不会添加额外的空字符。

3. 重叠字符串：如果源字符串和目标字符串有重叠，strncat 的行为是未定义的。在这种情况下，应使用 memmove 函数。

4. 性能：strncat 的时间复杂度是 O(m+n)，其中 m 是 dest 的长度，n 是追加的字符数。

5. 返回值：strncat 返回目标字符串的指针，这可以用于链式操作。

strncat 是一个有用的函数，用于在追加字符串时控制最大追加的字符数，但需要确保目标字符串有足够的空间来存储结果。在可能的情况下，使用 strlcat 或其他更安全的字符串操作函数可能是更好的选择。

8.strstr函数

strstr 是 C 语言标准库中的一个函数，用于在一个字符串中查找第一次出现的另一个字符串，并返回第一次出现的位置。如果找不到子字符串，则返回 NULL。

函数原型如下：

char *strstr(const char *haystack, const char *needle);
//haystack：指向要搜索的字符串（主字符串）的指针。
//needle：指向要查找的子字符串的指针。

返回值

strstr 函数返回一个指向 haystack 中第一次出现 needle 的位置的指针。如果 needle 是空字符串，strstr 返回 haystack。如果 needle 在 haystack 中没有出现，则返回 NULL。

示例代码

以下是使用 strstr 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strstr 函数的头文件

int main() {
    char haystack[] = "Hello, World!";
    char needle1[] = "World";
    char needle2[] = "C++";

    char *result1 = strstr(haystack, needle1); // 在 haystack 中查找 needle1
    char *result2 = strstr(haystack, needle2); // 在 haystack 中查找 needle2

    if (result1 != NULL) {
        printf("'%s' found in '%s'\n", needle1, haystack);
    } else {
        printf("'%s' not found in '%s'\n", needle1, haystack);
    }

    if (result2 != NULL) {
        printf("'%s' found in '%s'\n", needle2, haystack);
    } else {
        printf("'%s' not found in '%s'\n", needle2, haystack);
    }

    return 0;
}

注意事项

1. 大小写敏感：strstr 是大小写敏感的，所以 "Hello" 和 "hello" 会被认为是不同的字符串。

2. 空字符串：如果 needle 是空字符串，strstr 返回 haystack 的指针。

3. 重叠字符串：strstr 可以正确处理 haystack 和 needle 重叠的情况。

4. 性能：strstr 的时间复杂度是 O(n*m)，其中 n 是 haystack 的长度，m 是 needle 的长度。

5. 返回值：strstr 的返回值是一个指针，可以用来进一步操作找到的子字符串。

6. NULL 检查：在使用 strstr 的返回值之前，应该检查是否为 NULL，以避免解引用空指针。

strstr 函数是处理字符串搜索任务的有用工具，但使用时需要注意其性能和返回值的处理。

9.strtok函数

strtok 是 C 语言标准库中的一个函数，用于根据分隔符分割字符串。它是一个可重入的函数，可以在多次调用中使用，每次调用都会返回下一个分割后的子字符串。

函数原型如下：

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

//str：指向要分割的字符串的指针。在第一次调用时，str 应该是要分割的字符串的地址。在随后的调用中，str 应该是 NULL，以便函数继续处理上次调用后剩余的字符串。

//delim：指向定义分隔符集合的字符串。

返回值

strtok 函数返回一个指向下一个子字符串的指针。当没有更多的子字符串时，返回 NULL。

示例代码

以下是使用 strtok 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strtok 函数的头文件

int main()
 {
    char str[] = "Hello, World! This is a test.";
    char *token;
    const char *delim = " ,!";

    // 获取第一个子字符串
    token = strtok(str, delim);

    // 循环获取剩余的子字符串
    while (token != NULL) 
{
        printf("%s\n", token);
        token = strtok(NULL, delim); // 在后续调用中传递 NULL
    }

    return 0;
}

注意事项

1. 线程安全：strtok 不是线程安全的，因为它使用了静态缓冲区来存储数据。在多线程环境中，应使用 strtok_r。

2. 修改原字符串：strtok 会修改原始字符串，通过在每个分割的子字符串后面插入空字符 \0。

3. 分隔符：strtok 会跳过分隔符，并返回第一个非分隔符字符开始的子字符串。

4. 返回值：strtok 返回的指针指向的子字符串不应被修改，因为它们是原始字符串的一部分。

5. NULL 检查：在使用 strtok 的返回值之前，应该检查是否为 NULL，以避免解引用空指针。

strtok 函数是处理字符串分割任务的有用工具，但使用时需要注意其对原字符串的修改和线程安全问题。在现代编程实践中，推荐使用 strtok_r 或其他更安全的替代函数。

10.strerror函数

strerror 是 C 语言标准库中的一个函数，它用于将整型错误码转换为对应的错误描述字符串。这个函数是处理错误时的有用工具，因为它提供了一种将系统错误码转换为可读字符串的方法。

函数原型如下：

char *strerror(int errnum);
//errnum：一个整型错误码，通常是 errno 变量的值，errno 是一个全局变量，用于存储最近一次库函数调用中发生的错误码。

返回值

strerror 函数返回一个指向错误描述字符串的指针。这个字符串是只读的，不应该被修改。

示例代码

以下是使用 strerror 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 strerror 函数的头文件

int main() 
{
    char buffer[128];
    int result = strerror_r(ENOMEM, buffer, sizeof(buffer));

    if (result == 0) 
    {
        printf("Error: %s\n", buffer);
    } 
else 
    {
        printf("Failed to get error message.\n");
    }

    return 0;
}

注意事项

1. 线程安全：strerror 函数是非线程安全的，因为它可能修改全局变量 errno。在多线程环境中，应使用 strerror_r，这是一个线程安全的替代函数。

2. 错误描述字符串：返回的错误描述字符串是静态分配的，不应该被修改。

3. 返回值：strerror 返回的是一个指向只读字符串的指针，这个字符串描述了对应的错误。

4. 错误码：errnum 参数应该是一个有效的错误码，通常是 errno 变量的值。

5. 可移植性：strerror 函数的行为在不同系统上可能略有不同，特别是在错误描述字符串的内容和语言上。

strerror 函数是处理错误时的有用工具，它提供了一种将系统错误码转换为人类可读字符串的方法。在多线程程序中，应优先考虑使用 strerror_r 以确保线程安全。

11.memcpy函数

memcpy 是 C 语言标准库中的一个函数，用于从源内存地址复制指定数量的字节到目标内存地址。这个函数在处理内存操作时非常有用，尤其是在需要精确控制数据复制时。

函数原型如下：

void *memcpy(void *dest, const void *src, size_t n);
//dest：指向目标内存块的指针，数据将被复制到这个位置。
//src：指向源内存块的指针，数据将从这个位置复制。
//n：要复制的字节数。

返回值

memcpy 函数返回一个指向目标内存块 dest 的指针。

示例代码

以下是使用 memcpy 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 memcpy 函数的头文件

int main() 
{
    char src[] = "Hello, World!";
    char dest[20]; // 确保目标数组足够大以存储 src 字符串

    // 使用 memcpy 复制字符串
    memcpy(dest, src, sizeof(src));

    printf("Copied string: %s\n", dest);

    return 0;
}

注意事项

1. 重叠区域：如果源和目标内存区域重叠，memcpy 的行为是未定义的。在这种情况下，应使用 memmove 函数。

2. 内存对齐：memcpy 通常假设内存是适当对齐的，这可能影响性能。如果性能是关键考虑因素，并且数据类型不是字节对齐的，可能需要使用特定于数据类型的复制函数，如 memmove 或其他优化的函数。

3. 空终止符：memcpy 不会自动添加空终止符 \0，如果复制的是字符串，需要手动处理空终止符。

4. 返回值：memcpy 返回目标内存块的指针，这可以用于链式操作，例如 memcpy(dest, src, n); memset(dest + n, 0, m);。

5. 类型安全：memcpy 本身不提供类型安全，因为它只处理字节级别的复制。确保目标和源的类型兼容，并且目标有足够的空间来接收复制的数据。

memcpy 是一个强大的工具，用于在内存中复制数据，但需要谨慎使用，以避免潜在的错误和安全问题。

12.memove函数

memmove 是 C 语言标准库中的一个函数，用于从源内存地址复制指定数量的字节到目标内存地址。与 memcpy 不同，memmove 可以处理源和目标内存区域重叠的情况，因为它在复制时考虑到了这种可能性。

函数原型如下：

void *memmove(void *dest, const void *src, size_t n);
//dest：指向目标内存块的指针，数据将被复制到这个位置。
//src：指向源内存块的指针，数据将从这个位置复制。
//n：要复制的字节数。

返回值

memmove 函数返回一个指向目标内存块 dest 的指针。

示例代码

以下是使用 memmove 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 memmove 函数的头文件

int main() {
    char src[] = "Hello, World!";
    char dest[20]; // 确保目标数组足够大以存储 src 字符串

    // 使用 memmove 复制字符串
    memmove(dest, src, sizeof(src));

    printf("Copied string: %s\n", dest);

    return 0;
}

注意事项

1. 重叠区域：memmove 可以安全地处理源和目标内存区域重叠的情况，这是它与 memcpy 的主要区别。

2. 内存对齐：与 memcpy 一样，memmove 通常假设内存是适当对齐的。

3. 空终止符：memmove 不会自动添加空终止符 \0，如果复制的是字符串，需要手动处理空终止符。

4. 返回值：memmove 返回目标内存块的指针，这可以用于链式操作。

5. 类型安全：与 memcpy 一样，memmove 不提供类型安全，因为它只处理字节级别的复制。确保目标和源的类型兼容，并且目标有足够的空间来接收复制的数据。

memmove 是一个有用的工具，特别是在需要复制的数据区域可能重叠时。它通过在复制过程中采取额外的步骤来确保数据的正确复制，即使在重叠的情况下也能安全使用。

13.memcmp函数

memcmp 是 C 语言标准库中的一个函数，用于比较两个内存区域。它逐字节比较两个内存块，直到比较完指定的字节数或发现不同。

函数原型如下：

int memcmp(const void *str1, const void *str2, size_t n);
//str1：指向第一个内存块的指针。
//str2：指向第二个内存块的指针。
//n：要比较的最大字节数。

返回值

memcmp 函数返回一个整数，表示比较结果：

• 如果 str1 小于 str2，则返回值小于 0。
• 如果 str1 等于 str2，则返回值等于 0。
• 如果 str1 大于 str2，则返回值大于 0。

示例代码

以下是使用 memcmp 函数的一个简单示例：

#include <stdio.h>
#include <string.h> // 包含 memcmp 函数的头文件

int main() {
    const char str1[] = "Hello";
    const char str2[] = "World";
    const char str3[] = "Hello";

    int result1 = memcmp(str1, str2, sizeof(str1)); // 比较 str1 和 str2
    int result2 = memcmp(str1, str3, sizeof(str1)); // 比较 str1 和 str3

    if (result1 < 0) {
        printf("'%s' is less than '%s'\n", str1, str2);
    } else if (result1 > 0) {
        printf("'%s' is greater than '%s'\n", str1, str2);
    } else {
        printf("'%s' is equal to '%s'\n", str1, str2);
    }

    if (result2 == 0) {
        printf("'%s' is equal to '%s'\n", str1, str3);
    }

    return 0;
}

注意事项

1. 大小写敏感：memcmp 是大小写敏感的，所以 "Hello" 和 "hello" 会被认为是不相等的。

2. 空终止符：memcmp 不会自动停止在空字符 \0，它会继续比较直到指定的字节数 n 或发现不同。

3. 性能：memcmp 的时间复杂度是 O(n)，其中 n 是要比较的字节数。

4. 返回值：memcmp 的返回值可以用于条件语句和逻辑运算，因为它返回的是一个整数。

5. 安全性：在使用 memcmp 比较字符串时，确保不要超过字符串的实际长度，以避免未定义行为。

memcmp 函数是处理内存比较任务的有用工具，但使用时需要注意其性能和返回值的处理。

以上是通过人为整理的，如果有纰漏，还请小伙伴们帮忙指出纠正，嘻嘻@