memcpy和memmove的模拟实现以及结构体的大小

memcpy的模拟实现

memcpy的作用：拷贝。

int arr1[10]={1,2,3,4,5,6,7,8,9,10};
int arr2[10]={0};
memcpy(arr2,arr1,20);

这段代码可以使arr2中的元素变成1,2,3,4,5,0,0,0,0,0

即，arr2是目的地（你想拷贝到哪里去），arr1是源头（你想拷贝的内容是什么），20个字节是本次拷贝的长度。

值得注意的是，20指的是需要拷贝的字节数，而不是元素个数。

这是cplusplus中关于memcpy的介绍

如何模拟实现这个功能呢？

首先要保证我们自己写的函数的返回值类型和参数都与cplusplus中的一致，返回的是目标空间的起始地址

即void* my_memcpy(void* dest, const void* src, size_t num)

void* my_memcpy(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;//用一个指针存放dest的起始地址，这是我们要返回的东西
    while (num--)
    {
        *(char*)dest = *(char*)src;//以1字节为单位进行拷贝
        dest = (char*)dest + 1;
        src = (char*)src + 1;//让两者都以1字节为单位往后移动
    }
    return ret;//返回目标空间的起始地址
}

int main()
 {
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[10] = { 0 };
    //20指的是字节数，这跟内存的存储有关
    //如果输入17，由于是小端存放，也能将5放在arr1中
    //01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05
    my_memcpy(arr2, arr1, 20);
    return 0;
 }

---

memmove的模拟实现

我们写出了my_memcpy，在使用的过程中想到，能否让目标和源头都来自同一个数组呢？

于是写下了如下代码：

int main()
{ 
   int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
   my_memcpy(arr1+2, arr1, 20);
   return 0;
}

我们的预期是把arr1中的元素变成1,2,1,2,3,4,5,8,9,10

结果是这样：

显然这样并不符合我们的预期，这样的函数很是存在一定缺陷的，而出现这种情况的原因在于，

当我们想把arr1的前五个元素拷贝至原先的3,4,5,6,7的位置时，由于1将3替换，2将4替换，导致原先的3不复存在，变成了1，我们只能取出这里的1，将其放在原先5的位置，以此类推，便出现了现在这种情况，

而函数memmove的目标就是避免这种错误。

它的功能和memcpy一样，但可以防止上面这种情况的发生。

它和memcpy的不同之处在于，将所有情境分为两种情况，选择从前向后拷贝或从后向前拷贝。

而memcpy却只考虑了一种情况，即从前往后拷贝，我们设想，如果在当前这种情况（即dest>src时）从后往前打印，就不会出现上面那种把想要的数字提前覆盖的情况了。

相较于my_memcpy，我们只需要在这个基础上增加一个从后向前拷贝的逻辑。

代码如下：

void* my_memmove(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;
    if (dest < src)
    {
        //从前向后拷贝，逻辑同memcpy
        while (num--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else//合并了当dest=src的情况，因为这样的情况不论从前向后还是从后向前拷贝，都可以实现
    {
        //从后向前拷贝
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    return ret;
}

int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    my_memmove(arr1, arr1 + 2, 20);
    return 0;
}

---

结构体

结构是一些值的集合，这些值被称为成员变量。结构的每个成员可以是不同类型的变量。

与数组相似，但数组是类型相同的值的集合。

结构体所占内存的大小是多少呢？

例如

struct S1
{
    char c1;
    int i;
    char c2;//如果单纯计算大小，1+4+1=6字节
};

struct S2
{
    char c1;
    char c2;
    int i;//如果单纯计算大小，为1+1+4=6字节
};

我们用sizeof(struct S1)和sizeof(struct S2)去计算其大小，得到的结果是12和8，而非预期中的6字节和6字节。

这是因为结构体的内存对齐

规则如下：

1.结构体的第一个成员，对齐到结构体在内存中存放位置的0偏移处。

2.从第二个成员开始，每个成员都要对齐到（一个对齐数）的整数倍处。对齐数：结构体成员自身大小和默对齐数的较小值。在VS系统中，默认对齐数是8；在linux gcc中没有默认对齐数，对齐数就是结构体成员的自身大小。

3.结构体的总大小，必须是所有成员的对齐数中最大对齐数的整数倍

4.如果结构体中嵌套了结构体成员，要将嵌套的结构体成员对齐到自己成员中最大对齐数的整数倍处。结构体的总大小必须是最大对齐数的整数倍（这里的最大对齐数是指：包含嵌套结构体成员中的对齐数的所有对齐数中的最大值）

这样的方式会浪费掉一些空间，同时可以减少内存访问次数从而节省时间

总的来说，这是一种牺牲空间换取时间的做法。