【【萌新的c语言学习-9】】

萌新的c语言学习-9

//如何实现memcpy的自定义
memcpy 主打的就是复制内存的作用
struct s
{
char name[20];
int age;
};
int main()
{
struct s arr3[] = { {"张三",20},{"李四",30}};
struct s arr4[3] = { 0 };
memcpy(arr4, arr3, sizeof(arr3));
return 0;
}

/自定义

#include<assert.h>
 void* my_mencpy(void* dest, const void* src, size_t num)
{
     //因为void* 可以接受任意类型的指针 但是不能对他进行解引用操作
     //
     void* ret = dest;
     assert(dest != NULL);
     assert(src != NULL);
     while (num--)
     {
         *(char*)dest = *(char*)src;
         ++(char*)dest;
         ++(char*)src;
     }
     return ret;
}
struct s
{
    char name[20];
    int age;
};
int main()
{
    struct s arr3[] = { {"张三",20},{"李四",30} };
    struct s arr4[3] = { 0 };
    my_mencpy(arr4, arr3, sizeof(arr3));
    return 0;
}

---

#include<assert.h>
 void* my_mencpy(void* dest, const void* src, size_t num)
{
     //因为void* 可以接受任意类型的指针 但是不能对他进行解引用操作
     
     void* ret = dest;
     assert(dest != NULL);
     assert(src != NULL);
     while (num--)
     {
         *(char*)dest = *(char*)src;
         ++(char*)dest;
         ++(char*)src;
     }
     return ret;
}
//我们现在的做法是把1 2 3 4 5的数据放到34567上去
int main()
{
    int i = 0;
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };    
    my_mencpy(arr+2,arr,20);
    for (i = 0; i < 10; i++)
    {
        printf("%d\n", arr[i]);
    }
    return 0;
}//这里最后的结果是121212189 10 
//和我们预计的有所不符合 我们希望的是1 2 1 2 3 4 5 8 9 10
//出现问题的原因是我们都是用的一整个memcpy这样的话原数据其实被修改了
//所以才会传错 我们需要将原数据的范围
//既然会覆盖的话我们从后往前行不行，在这个形式可以，但是别的数字可能不行
//memmove是用来处理内存重叠拷贝的
用memmove

---

#include<assert.h>
 void* my_mencpy(void* dest, const void* src, size_t num)
{
     //因为void* 可以接受任意类型的指针 但是不能对他进行解引用操作
     
     void* ret = dest;
     assert(dest != NULL);
     assert(src != NULL);
     while (num--)
     {
         *(char*)dest = *(char*)src;
         ++(char*)dest;
         ++(char*)src;
     }
     return ret;
}

//我们现在的做法是把1 2 3 4 5的数据放到34567上去

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

/这里最后的结果是121212189 10
//和我们预计的有所不符合 我们希望的是1 2 1 2 3 4 5 8 9 10
//出现问题的原因是我们都是用的一整个memcpy这样的话原数据其实被修改了
//所以才会传错 我们需要将原数据的范围
//既然会覆盖的话我们从后往前行不行，在这个形式可以，但是别的数字可能不行
//memmove是用来处理内存重叠拷贝的
//怎么实现
//我们在此处先对memmove进行自我设计
//dest落在了src的左边 就从前向后拷贝
//要是dest落在了src的右边，就从后向前拷贝

---

#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t count)
{
    char* ret = dest;
    //为了不让源变化 src赋予 const
    assert(dest != NULL);
    assert(src != NULL);
    
    while (count--)
    {
        *(char*)dest = *(char*)src;
        ++(char*)dest;
        ++(char*)src;
    }
    return dest;
}
int main()
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[10] = { 0 };
    my_memcpy(arr2, arr1, sizeof(arr1));
    return 0;
}

/
//解决重叠的问题办法是

// memmove
void* my_memmove(void* dest, const void* src, size_t count)
{
    assert(dest != NULL);
    assert(src != NULL);
    if (dest < src)
    {
        while (count--)
        {
            *(char*)dest = *(char*)src;
            ++(char*)dest;
            ++(char*)src;
        }
    }
    else
    {
        //后向前
        while (count--)
        {
            *((char*)dest + count) = *((char*)src + count);
        }
    }
}
/

---

void* my_memmove(void* dest, const void* src, size_t count)
{
    assert(dest != NULL);
    assert(src != NULL);
    if (dest < src||dest>((char*) src+count))
    {
        while (count--)
        {
            *(char*)dest = *(char*)src;
            ++(char*)dest;
            ++(char*)src;
        }
    }
    else
    {
        //后向前
        while (count--)
        {
            *((char*)dest + count) = *((char*)src + count);
        }
    }
}