C/C++常用库函数
码字不易，烦请点赞和收藏，持续更新中~
目录
字符串函数
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
Youstrtol
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: 0000000000memcmp
?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;
}本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！