库函数的模拟实现（详解）_库函数的实现-CSDN博客

本文链接：https://blog.csdn.net/z6665454/article/details/137090593

一.库函数

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

1.字符串函数

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

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

2.内存函数

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

malloc(): 用于在堆（heap）中动态分配指定大小的内存空间，并返回指向分配内存的指针。函数原型为：void *malloc(size_t size);
calloc(): 用于在堆（heap）中动态分配指定数量和大小的内存空间，并初始化为零。函数原型为：void *calloc(size_t num, size_t size);
realloc(): 用于重新调整之前分配的内存空间的大小。可以用来扩大或缩小内存空间。函数原型为：void *realloc(void *ptr, size_t size);
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;
}