库函数的模拟实现（详解）

大家好，欢迎来到IT知识分享网。

一.库函数

 C语言的库函数是预先编写好的、可重复使用的函数集合，以供程序员在编写C语言程序时调用和使用。库函数通常由编译器或操作系统提供，它们实现了一系列常见的功能，如输入输出、内存管理、字符串操作、数学运算等。

1.字符串函数

字符串函数是C语言中常用的库函数，用于对字符串进行操作和处理。这些函数可以在C标准库中找到，以及其他自定义的库中。下面介绍几个常用的字符串函数：

1. strlen(): 用于计算字符串的长度，即字符串中字符的个数（不包括空字符’\0’）。函数原型为：size_t strlen(const char *str);
2. strcpy(): 用于将一个字符串复制到另一个字符串中。函数原型为：char *strcpy(char *dest, const char *src);
3. strcat(): 用于将一个字符串连接到另一个字符串的末尾。函数原型为：char *strcat(char *dest, const char *src);
4. strcmp(): 用于比较两个字符串的大小。函数返回值为0表示两个字符串相等，小于0表示第一个字符串小于第二个字符串，大于0表示第一个字符串大于第二个字符串。函数原型为：int strcmp(const char *str1, const char *str2);
5. strchr(): 用于在一个字符串中查找指定字符的第一次出现位置。函数返回指向该字符的指针，如果没有找到，则返回NULL。函数原型为：char *strchr(const char *str, int c);
6. strstr(): 用于在一个字符串中查找指定子字符串的第一次出现位置。函数返回指向该子字符串的指针，如果没有找到，则返回NULL。函数原型为：char *strstr(const char *haystack, const char *needle);
7. strtok(): 用于将一个字符串分割成多个子字符串（标记）。函数原型为：char *strtok(char *str, const char *delimiters);

2.内存函数

内存函数是C语言中用于动态内存管理的库函数，它们可以在程序运行时进行内存的分配、释放和操作。下面介绍几个常用的内存函数：

1. malloc(): 用于在堆（heap）中动态分配指定大小的内存空间，并返回指向分配内存的指针。函数原型为：void *malloc(size_t size);
2. calloc(): 用于在堆（heap）中动态分配指定数量和大小的内存空间，并初始化为零。函数原型为：void *calloc(size_t num, size_t size);
3. realloc(): 用于重新调整之前分配的内存空间的大小。可以用来扩大或缩小内存空间。函数原型为：void *realloc(void *ptr, size_t size);
4. free(): 用于释放之前通过malloc、calloc或realloc分配的内存空间，回收内存供系统重新使用。函数原型为：void free(void *ptr);

二.字符串函数的模拟实现

1. strlen的模拟实现

strlen(const char* str)：strlen 函数用于计算字符串的长度，即字符串中字符的个数，不包括字符串结尾的空字符 ‘\0’。它接受一个指向字符串开头的指针，并通过遍历字符串的每个字符来确定长度。它返回一个 size_t 类型的值，表示字符串的长度。

#include <stdio.h> size_t strlen(const char* str) { size_t length = 0; while (str[length] != '\0') { length++; } return length; } int main() { const char* str = "Hello, World!"; size_t length = strlen(str); printf("Length of the string: %zu\n", length); return 0; }

2. strcpy的模拟实现

strcpy(char* dest, const char* src)：strcpy 函数用于将一个字符串（源字符串）复制到另一个字符串（目标字符串）中。它接受两个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针。函数会将源字符串的内容复制到目标字符串中，直到遇到源字符串的结尾字符 ‘\0’。它返回指向目标字符串的指针。

#include <stdio.h> char* strcpy(char* dest, const char* src) { char* temp = dest; while (*src != '\0') { *dest = *src; dest++; src++; } *dest = '\0'; return temp; } int main() { char source[] = "Hello, World!"; char destination[20]; strcpy(destination, source); printf("Copied string: %s\n", destination); return 0; }

3. strcat的模拟实现

strcat(char* dest, const char* src)：strcat 函数用于将一个字符串（源字符串）追加到另一个字符串（目标字符串）的末尾。它接受两个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针。函数会将源字符串的内容追加到目标字符串的末尾，并在最后添加一个结尾字符 ‘\0’。它返回指向目标字符串的指针。

#include <stdio.h> char* strcat(char* dest, const char* src) { char* temp = dest; while (*dest != '\0') { dest++; } while (*src != '\0') { *dest = *src; dest++; src++; } *dest = '\0'; return temp; } int main() { char str1[50] = "Hello"; char str2[] = ", World!"; strcat(str1, str2); printf("Concatenated string: %s\n", str1); return 0; }

4. strcmp的模拟实现

strcmp(const char* str1, const char* str2)：strcmp 函数用于比较两个字符串的大小关系。它接受两个参数，分别是要比较的两个字符串的指针。函数会逐个比较字符串中的字符，直到遇到不同的字符或其中一个字符串的结尾字符 ‘\0’。如果两个字符串相等，函数返回值为 0；如果第一个字符串小于第二个字符串，返回值为负数；如果第一个字符串大于第二个字符串，返回值为正数。

#include <stdio.h> int strcmp(const char* str1, const char* str2) { while (*str1 && (*str1 == *str2)) { str1++; str2++; } return *(unsigned char*)str1 - *(unsigned char*)str2; } int main() { const char* str1 = "Hello"; const char* str2 = "World"; int result = strcmp(str1, str2); if (result < 0) { printf("str1 is less than str2\n"); } else if (result > 0) { printf("str1 is greater than str2\n"); } else { printf("str1 is equal to str2\n"); } return 0; }

5. strncpy函数的模拟实现

strncpy(char* dest, const char* src, size_t n)：strncpy 函数用于将指定长度的源字符串复制到目标字符串中。它接受三个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针，第三个参数是要复制的字符数。如果源字符串的长度小于指定的字符数，那么目标字符串会被复制的字符填充直到达到指定的字符数。函数会在最后一个复制的字符之后添加结尾字符 ‘\0’。它返回指向目标字符串的指针。

#include <stdio.h> char* strncpy(char* dest, const char* src, size_t n) { char* temp = dest; while (n > 0 && *src != '\0') { *dest = *src; dest++; src++; n--; } while (n > 0) { *dest = '\0'; dest++; n--; } return temp; } int main() { const char* src = "Hello, World!"; char dest[20]; size_t n = 10; strncpy(dest, src, n); printf("Copied string: %s\n", dest); return 0; }

6. strncat函数的模拟实现

strncat(char* dest, const char* src, size_t n)：strncat 函数用于将指定长度的源字符串追加到目标字符串的末尾。它接受三个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针，第三个参数是要追加的字符数。如果源字符串的长度小于指定的字符数，那么源字符串的全部内容都会被追加到目标字符串的末尾。函数会在追加完源字符串后，在目标字符串的末尾添加结尾字符 ‘\0’。它返回指向目标字符串的指针。

#include <stdio.h> char* strncat(char* dest, const char* src, size_t n) { char* temp = dest; while (*dest != '\0') { dest++; } while (n > 0 && *src != '\0') { *dest = *src; dest++; src++; n--; } *dest = '\0'; return temp; } int main() { char str1[50] = "Hello"; char str2[] = ", World!"; size_t n = 7; strncat(str1, str2, n); printf("Concatenated string: %s\n", str1); return 0; }

7. strstr函数的模拟实现

strstr(const char* str, const char* substr)：strstr 函数用于在一个字符串中查找子字符串的出现位置。它接受两个参数，第一个参数是要搜索的字符串的指针，第二个参数是要查找的子字符串的指针。函数会在目标字符串中搜索子字符串的第一次出现，并返回一个指向该位置的指针。如果子字符串不存在于目标字符串中，函数返回 NULL。

#include <stdio.h> const char* strstr(const char* str, const char* substr) { if (*substr == '\0') return str; while (*str) { const char* temp_str = str; const char* temp_substr = substr; while (*temp_str && *temp_substr && (*temp_str == *temp_substr)) { temp_str++; temp_substr++; } if (*temp_substr == '\0') return str; str++; } returnstr; } int main() { const char* str = "Hello, World!"; const char* substr = "World"; const char* result = strstr(str, substr); if (result != NULL) { printf("Substring found at position: %ld\n", result - str); } else { printf("Substring not found\n"); } return 0; }

二.内存函数的模拟实现

1. memcpy函数的模拟实现

memcpy(void* dest, const void* src, size_t n)：memcpy 函数用于将一段内存块的内容从源地址复制到目标地址。它接受三个参数，第一个参数是目标地址的指针，第二个参数是源地址的指针，第三个参数是要复制的字节数。函数会将源地址开始的连续字节复制到目标地址中，包括字节中的所有数据和字节的值。它返回指向目标地址的指针。

#include <stdio.h> void* memcpy(void* dest, const void* src, size_t n) { char* dest_ptr = (char*)dest; const char* src_ptr = (const char*)src; while (n > 0) { *dest_ptr = *src_ptr; dest_ptr++; src_ptr++; n--; } return dest; } int main() { int src[] = {1, 2, 3, 4, 5}; int dest[5]; size_t n = sizeof(src); memcpy(dest, src, n); for (int i = 0; i < 5; i++) { printf("%d ", dest[i]); } printf("\n"); return 0; }

2. memmove函数的模拟实现
 

memmove(void* dest, const void* src, size_t n)：memmove 函数类似于 memcpy 函数，也用于将一段内存块的内容从源地址复制到目标地址。它的区别在于，memmove 函数能够处理源地址和目标地址重叠的情况，而 memcpy 函数则不能。如果源地址和目标地址重叠，memmove 函数会先将数据复制到临时缓冲区，然后再从缓冲区复制到目标地址，以确保数据的正确性。它返回指向目标地址的指针。

#include <stdio.h> void* memmove(void* dest, const void* src, size_t n) { char* dest_ptr = (char*)dest; const char* src_ptr = (const char*)src; if (dest_ptr < src_ptr) { while (n > 0) { *dest_ptr = *src_ptr; dest_ptr++; src_ptr++; n--; } } else if (dest_ptr > src_ptr) { dest_ptr += n; src_ptr += n; while (n > 0) { dest_ptr--; src_ptr--; *dest_ptr = *src_ptr; n--; } } return dest; } int main() { int arr[] = {1, 2, 3, 4, 5}; memmove(arr + 2, arr, 3 * sizeof(int)); for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); } printf("\n"); return 0; }