C/C++常用库函数

码字不易，烦请点赞和收藏，持续更新中~

---

目录

字符串函数

strlen

sizeof

strchr

strstr

strcpy

strncpy

strcat

strncat

strcmp

?strncmp

strtok

strtol

内存操作函数

memset

memcmp

?memchr

memcpy

memmove

memcpy和memmove区别

文件I/O操作函数

open

write?

read

I/O操作实例

---

字符串函数

strlen

strlen 函数是 C 语言中字符串长度函数，它计算字符串中字符的个数，不包括字符串结束符 '\0'。strlen 函数的函数原型如下：

size_t strlen(const char *str);

其中，str 是指向字符串的指针。strlen 函数返回字符串 str 的长度，即字符串中字符的个数。 以下是 strlen 函数的使用示例：

#include <stdio.h>

int main() {
    char str[] = "Hello, world!";
    int len = strlen(str);
    printf("The length of the string is %d.\n", len);
    return 0;
}

当程序运行时，输出结果如下：

The length of the string is 13.

在实际运用中，需要注意sizeof函数和strlen函数的区别，因此这里再介绍一下sizeof函数。

sizeof

sizeof函数是C和C++语言中的一个运算符，用于获取变量或数据类型所占用的内存大小。它的语法形式为sizeof(expression)，其中expression可以是变量、数据类型或者表达式。

sizeof函数的返回值是一个无符号整数，表示以字节为单位的内存大小。它在编译时就能够确定，不需要运行时计算。

sizeof函数的使用有以下几个特点：

1. sizeof可以用于获取各种数据类型的大小，包括基本数据类型（如int、float、char等）、数组、结构体、指针等。

2. sizeof对于数组，返回的是整个数组占用的内存大小，而不是数组元素的个数。

3. sizeof对于指针，返回的是指针本身所占用的内存大小，而不是指针指向的内存大小。

4. sizeof对于结构体，返回的是结构体中所有成员变量占用的内存大小之和，可能会包含一些填充字节。

5. sizeof对于函数，返回的是函数指针的大小。

sizeof函数在编程中常用于以下几个方面：

1. 动态内存分配：在使用malloc、calloc等函数分配内存时，可以使用sizeof来计算所需的内存大小。

2. 数组操作：可以使用sizeof来计算数组的长度，以便进行遍历或者其他操作。

3. 结构体操作：可以使用sizeof来计算结构体的大小，以便进行内存布局和对齐等操作。

4. 指针操作：可以使用sizeof来判断指针的类型，或者计算指针数组的大小。 需要注意的是，sizeof函数返回的是一个常量表达式，在编译时就能够确定，不会随着程序的执行而改变。

下面是一些使用sizeof函数的示例代码：

#include <stdio.h>

int main() {
    int a;
    float b;
    char c;
    int arr[5];
    struct {
        int x;
        int y;
    } point;
    
    printf("Size of int: %zu\n", sizeof(int));
    printf("Size of float: %zu\n", sizeof(float));
    printf("Size of char: %zu\n", sizeof(char));
    printf("Size of array: %zu\n", sizeof(arr));
    printf("Size of struct: %zu\n", sizeof(point));
    
    return 0;
}

输出结果为：

Size of int: 4
Size of float: 4
Size of char: 1
Size of array: 20
Size of struct: 8

从输出结果可以看出，int和float类型的大小都是4字节，char类型的大小是1字节，数组arr的大小是20字节（5个int类型的元素，每个元素占4字节），结构体point的大小是8字节（两个int类型的成员变量，每个成员变量占4字节）。

strchr

strchr函数是C语言中的字符串处理函数，用于在一个字符串中查找指定字符的第一次出现位置，并返回该位置的指针。函数的原型为：

char *strchr(const char *str, int c);

其中，str是要查找的字符串，c是要查找的字符。如果找到了指定字符，则返回该字符在字符串中的指针；如果未找到，则返回NULL。

以下是 strchr函数的使用示例：

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

int main() {
    char str[] = "Hello, World!";
    char *ptr = strchr(str, 'o');
    
    if (ptr != NULL) {
        printf("Found at position: %ld\n", ptr - str);
    } else {
        printf("Not found\n");
    }
    
    return 0;
}

输出结果为：

Found at position: 4

strstr

strstr函数也是C语言中的字符串处理函数，用于在一个字符串中查找指定子串的第一次出现位置，并返回该位置的指针。函数的原型为：

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

其中，haystack是要查找的字符串，needle是要查找的子串。如果找到了指定子串，则返回该子串在字符串中的指针；如果未找到，则返回NULL。

以下是 strstr函数的使用示例：

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

int main() {
    char str[] = "Hello, World!";
    char *ptr = strstr(str, "World");
    
    if (ptr != NULL) {
        printf("Found at position: %ld\n", ptr - str);
    } else {
        printf("Not found\n");
    }
    
    return 0;
}

输出结果为：

Found at position: 7

总结起来，strchr函数用于查找指定字符的位置，而strstr函数用于查找指定子串的位置。两者都返回找到的位置的指针，如果未找到，则返回NULL。

strcpy

strcpy()函数用于将一个字符串复制到另一个字符串中。原型如下：

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

其中，参数dest是指向目标字符串的指针，参数src是指向源字符串的指针。

以下是 strcpy函数的使用示例：

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

int main()
{
    char str1[] = "Hello, world!";
    char str2[20];

    // 将字符串 str1 复制到字符串 str2 中
    strcpy(str2, str1);

    printf("str2: %s\n", str2);

    return 0;
}

当以上代码被编译并执行时，会输出以下结果：

str2: Hello, world!

strncpy

strncpy()函数用于将一个字符串复制到另一个字符串中，但最多复制n个字符。

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

其中，参数dest是指向目标字符串的指针，参数src是指向源字符串的指针，参数n是最多复制的字符数。

以下是 strncpy 函数的使用示例：

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

int main()
{
    char str1[] = "Hello, world!";
    char str2[20];

    // 将字符串 str1 的前 10 个字符复制到字符串 str2 中
    strncpy(str2, str1, 10);

    printf("str2: %s\n", str2);

    return 0;
}

当以上代码被编译并执行时，会输出以下结果：

str2: Hello, wor

strcat

strcat()函数用于将一个字符串连接到另一个字符串的末尾。

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

其中，参数dest是指向目标字符串的指针，参数src是指向源字符串的指针。

以下是 strcat 函数的使用示例：

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

int main()
{
    char str1[] = "Hello, world!";
    char str2[] = "Goodbye, world!";

    // 将字符串 str2 连接到字符串 str1 的末尾
    strcat(str1, str2);

    printf("str1: %s\n", str1);

    return 0;
}

当以上代码被编译并执行时，会输出以下结果：

str1: Hello, world!Goodbye, world!

strncat

strncat()函数用于将一个字符串连接到另一个字符串的末尾，但最多连接n个字符；如果源字符串的长度小于指定的字符数，那么目标字符串将不会以空字符结尾。

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

其中，参数dest是指向目标字符串的指针，参数src是指向源字符串的指针，参数n是最多连接的字符数。

以下是 strncat 函数的使用示例：

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

int main()
{
    char str1[] = "Hello, world!";
    char str2[] = "Goodbye, world!";

    // 将字符串 str2 的前 10 个字符连接到字符串 str1 的末尾
    strncat(str1, str2, 10);

    printf("str1: %s\n", str1);

    return 0;
}

当以上代码被编译并执行时，会输出以下结果：

str1: Hello, world!Goodbye, w

这是有的编译器会报错，或者会发现打印的内容与预想不一致；这是因为strncat函数在连接字符串时，会将指定的字符数连接到目标字符串的末尾，在这个例子中，

strncat(str1, str2, 10) 

将源字符串str2的前 10 个字符连接到目标字符串str1的末尾。由于str2的长度超过了指定的 10 个字符，因此str1不会以空字符结尾。 这意味着str1不是一个以空字符结尾的有效字符串，而是一个字符数组。因此，在日常使用中，一定要考虑目标字符串的大小。

strcmp

strcmp函数是C语言中的字符串比较函数，用于比较两个字符串是否相等。它的原型如下：

int strcmp(const char* str1, const char* str2);

其中，str1和str2是要比较的两个字符串。 strcmp函数的返回值有三种可能：

- 如果str1和str2相等，返回值为0。

- 如果str1小于str2，返回值为负数。

- 如果str1大于str2，返回值为正数。

strcmp函数是逐个字符比较两个字符串的函数,下面是strcmp函数的示例：

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

int main() {
    char str1[] = "ac";
    char str2[] = "bf";
    
    int result = strcmp(str1, str2);
    
    if(result == 0) {
        printf("str1和str2相等\n");
    } else if(result < 0) {
        printf("str1小于str2\n");
    } else {
        printf("str1大于str2\n");
    }
    
    return 0;
}

当以上代码被编译并执行时，会输出以下结果：?

str1和str2相等

在这个示例中，我们比较了两个字符串"ac"和"bf"。由于"ac"中第一个字符“a"小于"bf"中第一个字符”b"，所以strcmp函数返回一个负数，最终输出结果为"str1小于str2"。 需要注意的是，strcmp函数是按照字典序进行比较的，即比较两个字符串的每个字符的ASCII码值。如果字符串中包含中文或其他非ASCII字符，可能会出现不符合预期的结果。此外，strcmp函数只比较字符串的内容，不考虑字符串的长度。如果需要比较字符串的长度，可以使用strncmp函数。

?strncmp

strncmp函数是C语言中的字符串比较函数，用于比较两个字符串是否相等。它的原型如下：

int strncmp(const char* str1, const char* str2, size_t n);

其中，str1和str2是要比较的两个字符串，n为要比较的最大字符数。 strcmp函数的返回值有三种可能：

- 如果str1和str2相等，返回值为0。

- 如果str1小于str2，返回值为负数。

- 如果str1大于str2，返回值为正数。

两者不同之处是，strncmp函数是指定比较size个字符，而strcmp函数比较整个字符串，直到出现不同的字符或遇"\0"为止。下面是strcmp函数的示例：

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

int main() {
    char str1[] = "aabbd";
    char str2[] = "aaccd";
    
    int result = strncmp(str1, str2, 2);
    
    if(result == 0) {
        printf("str1和str2相等\n");
    } else if(result < 0) {
        printf("str1小于str2\n");
    } else {
        printf("str1大于str2\n");
    }
    
    return 0;
}

当以上代码被编译并执行时，会输出以下结果：

str1和str2相等

strtok

strtok函数是C语言中的一个字符串处理函数，用于将字符串分割成一系列子字符串。它的原型如下：

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

strtok函数接收两个参数：str为要分割的字符串，delim为分割符。它会将str字符串按照delim分割符进行切割，并返回分割后的第一个子字符串，之后每次调用该函数时，会返回下一个子字符串，直到所有子字符串都被返回完毕。

strtok函数的工作流程如下：

1. 在第一次调用时，str参数指向要分割的字符串，该字符串会被修改，将分割符替换为字符串结束符'\0'。

2. strtok函数会返回分割后的第一个子字符串的指针，并将下一个子字符串的位置记录在一个静态变量中。

3. 在后续的调用中，str参数传入NULL，表示继续使用上一次的位置，继续返回下一个子字符串的指针。

4. 当所有子字符串都被返回完毕时，strtok函数返回NULL。

需要注意的是，strtok函数在使用时需要小心，因为它会修改原始字符串，而且不是线程安全的。如果需要保留原始字符串，可以先将其复制到一个临时变量中再进行分割操作。

下面是一个使用strtok函数的示例：

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

int main() {
    char str[] = "Hello,World,How,Are,You";
    char *token = strtok(str, ",");
    while (token != NULL) {
        printf("%s\n", token);
        token = strtok(NULL, ",");
    }
    return 0;
}

以上示例会将字符串"Hello,World,How,Are,You"按照逗号分割成多个子字符串，并逐个打印出来。输出结果为：

How
Are
You

strtol

strtol函数是C语言中的一个标准库函数，用于将字符串转换为长整型数（long int）。函数原型如下：

long int strtol(const char *str, char **endptr, int base);

参数说明：

- str：要转换的字符串。

- endptr：指向一个指针，用于存储转换过程中未被转换的字符串部分的地址。如果该参数不为NULL，则会将未被转换的字符串部分的地址存储在endptr中。

- base：进制数，取值范围为2-36。如果base为0，则会根据字符串的前缀来判断进制数，如0x表示十六进制，0表示八进制，否则为十进制。

函数返回值： - 转换后的长整型数。 strtol函数会从字符串的开头开始解析，直到遇到非数字字符为止。如果字符串的开头是空白字符，则会忽略它们。如果字符串中没有可解析的数字，则返回0。如果转换过程中遇到非法字符，则会停止转换，并将停止转换的位置存储在endptr中（如果endptr不为NULL）。 示例代码：

#include <stdio.h>
#include <stdlib.h>

int main() {
    char str[] = "12345";
    char *endptr;
    long int num = strtol(str, &endptr, 10);
    
    printf("转换后的长整型数：%ld\n", num);
    printf("未被转换的字符串部分：%s\n", endptr);
    
    return 0;
}

输出结果：

转换后的长整型数：12345
未被转换的字符串部分：

在上述示例中，strtol函数将字符串"12345"转换为长整型数12345，并将未被转换的字符串部分的地址存储在endptr中。由于整个字符串都被成功转换，endptr为空字符串。

内存操作函数

memset

memset 函数用于将一个内存区域填充为指定的值。它的原型如下：

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

其中，dest 是目标内存区域的地址，c 是填充值，n 是需要填充的字节数。 memset 函数会从 dest 开始，将 c 填充到 dest 后面 n 个字节的位置。如果 dest 和 n 都为 NULL，则 memset 函数会返回 NULL。如果 n 为负数，则 memset 函数会返回 NULL。

以下是 memset 函数的使用示例：

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

int main() {
  char dest[10];

  memset(dest, '0', sizeof(dest));

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

  return 0;
}

运行这段代码，会输出以下结果：

dest: 0000000000

memcmp

?memcmp 函数用于比较两个内存区域的内容。它的原型如下：

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

其中，s1 是第一个内存区域的地址，s2 是第二个内存区域的地址，n 是需要比较的字节数。 memcmp 函数会比较 s1 和 s2 后面 n 个字节的内容，并返回第一个不同字节的差值。如果 s1 和 s2 完全相同，则 memcmp 函数返回 0。 以下是 memcmp 函数的使用示例：

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

int main() {
  char s1[] = "Hello, world!";
  char s2[] = "Hello, world!";

  int result = memcmp(s1, s2, strlen(s1) + 1);

  if (result == 0) {
    printf("The two strings are equal.\n");
  } else {
    printf("The two strings are not equal.\n");
  }

  return 0;
}

运行这段代码，会输出以下结果：

The two strings are equal.

?memchr

memchr函数是C语言中的一个字符串处理函数，它用于在一个内存区域中查找特定字符的第一次出现位置。 函数原型如下：

void *memchr(const void *str, char c, size_t n);

其中，str指向要搜索的内存区域的指针，c为要查找的字符，n为要搜索的字节数。memchr函数的工作原理是，从指定的内存区域开始逐个字节地搜索，直到找到指定字符或者搜索完整个区域。

如果找到指定字符，返回指向该字符的指针;

如果未找到指定字符，则返回NULL指针。

下面是一个示例代码，演示了如何使用memchr函数查找字符串中的特定字符：

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

int main() {
    char str[] = "Hello, World!";
    char *ptr = memchr(str, 'o', strlen(str));
    if (ptr != NULL) {
        printf("找到字符 'o'，位于位置 %ld\n", ptr - str);
    } else {
        printf("未找到字符 'o'\n");
    }
    return 0;
}

输出结果：

找到字符 'o'，位于位置 4

memcpy

memcpy 是 C 语言中的一个内存复制函数，它可以将一个内存区域的内容复制到另一个内存区域。它的原型如下：?

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

其中，dest 是目标内存区域的地址，src 是源内存区域的地址，n 是需要复制的字节数。 memcpy 函数的执行过程如下：

1. 首先，memcpy 函数会检查 dest 和 src 是否指向有效的内存区域。如果不指向有效的内存区域，则 memcpy 函数会返回 NULL。

2. 然后，memcpy 函数会检查 n 是否为正数。如果 n 为负数，则 memcpy 函数会返回 NULL。

3. 最后，memcpy 函数会从 src 开始，将 n 个字节的数据复制到 dest 中。

memcpy 函数是线程安全的，它可以安全地在多个线程中使用。 以下是 memcpy 函数的使用示例：

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

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

  memcpy(dest, src, strlen(src) + 1);

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

  return 0;
}

运行这段代码，会输出以下结果：

dest: Hello, world!

memmove

memmove 函数用于将一个内存区域的内容移动到另一个内存区域。它的原型如下：

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

其中，dest 是目标内存区域的地址，src 是源内存区域的地址，n 是需要移动的字节数。 memmove 函数会从 src 开始，将 src 后面 n 个字节的内容移动到 dest 中。如果 dest 和 src 有重叠，则 memmove 函数会保证 dest 中的内容不会被覆盖。 以下是 memmove 函数的使用示例：

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

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

  memmove(dest, src, strlen(src) + 1);

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

  return 0;
}

运行这段代码，会输出以下结果：

dest: Hello, world!

memcpy和memmove区别

1.memcpy在处理内存重叠时可能会导致未定义的行为，即结果不确定。而memmove会先将源地址的数据复制到一个临时缓冲区，然后再将临时缓冲区的数据复制到目标地址，从而避免了内存重叠带来的问题。

2.由于memmove需要使用额外的临时缓冲区，所以在处理大量数据时可能会比memcpy慢一些。但在处理小量数据或者存在内存重叠的情况下，memmove可能会更安全、更可靠。

文件I/O操作函数

open

open函数用于打开一个文件，返回一个文件描述符。它的原型如下

int open(const char *pathname, int flags, mode_t mode);

其中，pathname为要打开的文件的路径，flags为打开文件的方式和选项,常用的选项有:
-O_RDONLY:只读方式打开文件。
-O_WRONLY:只写方式打开文件。
-O_RDWR:读写方式打开文件。
-O_CREAT:如果文件不存在则创建文件。
-O_TRUNC:如果文件存在则截断文件。
mode未指定文件的权限,只有在创建文件时才有效。

详细说明：

write?

write函数：用于向已打开的文件写入数据。它的原型如下：

ssize_t write(int fd, const void *buf, size_t count);

其中，fd为文件描述符表示要写入的文件，buf为要写入的数据的缓冲区，count为要写入的数据的字节数。详细说明：

read

read函数：用于从已打开的文件读取数据。它的原型如下：

ssize_t read(int fd, void *buf, size_t count);

其中，fd为文件描述符表示要读的文件，buf为要写入的数据的缓冲区，count为要读出的数据的字节数。?详细说明：

I/O操作实例

#include <stdio.h>
#include <stdlib.h>

int main() {
  // 打开一个文件
  int fd = open("test.txt", O_RDWR | O_CREAT, 0644);
  if (fd == -1) {
    perror("open");
    exit(1);
  }

  // 向文件中写入数据
  char buf[] = "Hello, world!";
  int n = write(fd, buf, sizeof(buf));
  if (n == -1) {
    perror("write");
    exit(1);
  }

  // 从文件中读取数据
  char buf2[100];
  n = read(fd, buf2, sizeof(buf2));
  if (n == -1) {
    perror("read");
    exit(1);
  }

  // 关闭文件
  close(fd);

  return 0;
}