【结丹系列】 内存函数

内存函数可在任意类型使用，字符串函数只能比较字符串,内存函数不关注’\0’， 只关注要拷贝的字节数

一、memcpy

void * memcpy ( void * destination, const void * source, size_t num )

✔功能演示：参数类型必须是void*。因为memcpy函数是内存拷贝函数，它必须什么类型都能接收。

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置，这个函数在遇到 '\0' 的时候并不会停下来。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
    int arr1[] = {1,2,3,4,5,6,7,8,9 };
    int arr2[10] = {0};
    memcpy(arr2, arr1, 20);
    for (int i = 0; i < 10; i++) {
        printf("%d", arr2[i]);
    }
    return 0;
}

模拟实现memcpy

✔void 类型不能进行解引用操作和++运算，在解引用操作和++运算之前，要进行强制类型转换。并且因为此函数是一个字节一个字节的拷贝，所以要将ptr1和ptr2变量强制类型转化为char类型

✔目标变量dest的地址需要存放在一个临时指针变量中，因为dest在循环体中一直是变化的

✔将dest和sour指针变量assert断言，使其不为NULL。并且因为sour是不能改变的，所以用const修饰，以保护起来。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* sour, size_t num){
    assert(dest && sour);
    void* ret = dest;
    while(num--){
        *(char*)dest = *(char*)sour;
        dest = (char*)dest + 1;
        sour  = (char*)sour + 1;
    }
    return ret;
}
int main() {
    int arr1[] = {1,2,3,4,5,6,7,8,9 };
    int arr2[10] = {0};
    my_memcpy(arr2, arr1, 20);
    for (int i = 0; i < 10; i++) {
        printf("%d", arr2[i]);
    }
    return 0;
}

memcpy不支持自身内部拷贝，可能存在覆盖，主要负责拷贝两块独立空间中的数据，重叠内存拷贝使用memmove

二、memmove

void * memmove ( void * destination, const void * source, size_t num )

✔功能实现：如果源空间和目标空间出现重叠，就得使用memmove函数处理

#include<stdio.h>
int main() {
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10};
    int arr2[10] = {0};
    memmove(arr1, arr1+3, 20);
    for (int i = 0; i < 10; i++) {
        printf("%d", arr1[i]);
    }
    return 0;
}

模拟实现memmove

#include<
int main() {
    int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    int arr2[] = {2,3,4,5,6,7,8,9,10};
    my_memmove(arr1, arr1+2, 20);
    my_memmove(arr2+2, arr2, 8);
    for (int i = 0; i < 10; i++) {
        printf("%d", arr1[i]);
    }
    printf("\n");
    for (int i = 0; i < 9; i++) {
        printf("%d", arr2[i]);
    }
    return 0;
}

为避免出现空间重叠现象，根据dest 和 sour 的位置分情况处理，选择从前向后或从后向前拷贝

#include<assert.h>
#include<stdio.h>
void* my_memmove(void* dest, const void* sour, size_t num) {
    assert(dest && sour);
    void* ret = dest;
    if (dest < sour)
    {
    //前向后拷贝
        while (num--) 
        {
            *(char*)dest = *(char*)sour;
            dest = (char*)dest + 1;
            sour = (char*)sour + 1;
        }
    }
    else
    {
    //后向前拷贝
        while (num--)
        {
            *((char*)dest + num) = *((char*)sour + num);
        }
    }
    return ret;
}

三、memcmp

int memcmp ( const void * ptr1, const void * ptr2, size_t num )

✔功能实现：比较两个内存块，将 ptr1 所指向的内存块的前 num 个字节与 ptr2 指向的前num字节数进行比较, 返回不同意义的值

#include<stdio.h>
#include<string.h>
int main(){
    int arr1[] = { 1,5,4,5 };//01 00 00 00/ 05 00 00 00/ 04 00 00 00 /05 00 00 00
    int arr2[] = { 1,3,5,6 };//01 00 00 00/ 03 00 00 00 /05 00 00 00/ 06 00 00 00
    int ret = memcmp(arr1, arr2, 12);//arr1 > arr2
    printf("%d", ret);
    return 0;
}

模拟实现 memcpy()

✔void 类型不能进行解引用操作和++运算，在解引用操作和++运算之前，要进行强制类型转换。并且因为此函数是一个字节一个字节的拷贝，所以要将ptr1和ptr2变量强制类型转化为char类型

#include<stdio.h>
#include<assert.h>
int my_memcmp(const void* ptr1, const void* ptr2, size_t num) {
    assert(ptr1 && ptr2);
    while (num-- && *(char*)ptr1 == *(char*)ptr2){
              ptr1 = (char*)ptr1 +1;
              ptr2 = (char*)ptr2 +1;
        }
    return(*(char*)ptr1 - *(char*)ptr2);
}
int main(){
    //char arr1[] = "hello world";
    //char arr2[] = "hello bilibili";
    int arr1[] = { 1,5,7,5 };
    int arr2[] = { 1,5,7,6};
    int ret = my_memcmp(arr1, arr2, 12);
    if (ret == 0)
        printf("==\n");
    else if (ret < 0)
        printf("<\n");
    else
        printf(">\n");
    return 0;
}

四、memset()

void * memset ( void * ptr, int value, size_t num );

✔功能实现：将 ptr 所指向的内存块的前num个字节数设置为指定值

#include<stdio.h>
int main() {
    char arr[] = "hello bilibili";
    memset(arr, 'x', 5);
    printf("%s", arr);
    return 0;
}

模拟实现memset()

void* my_memset(void* ptr, int value, size_t num) {
    assert(ptr);
    void* ret = ptr;
    while (num--){
        *(char*)ptr = value;  //赋值
        ptr = (char*)ptr + 1; //q
    }
    return ret;
}