对rt_memcpy 函数的疑问

发布于 2019-03-10 08:45:36 浏览：4608 订阅该版

[tocm]

# rt_memcpy函数疑问

有一次面试，面试官让写一下c库memcpy函数实现。当时认为很简单，内存拷贝不就是赋值吗，所以快速的写了出来，回来后仔细想想有很多问题，研究了一下rt-thread的memcpy，看完之后有个地方不太明白，请教一下

*  先简单写一下面试时的情况，当时写的函数是这样的：

```c
void my_memcpy(char *const des,char *const res,int len)
{
    volatile int i=0;

if((dec == NULL)||(res == NULL))
       return;

for(i=0;i<len;i++)
    {
        (char *)des = (char *)res;
        des++;
        res++;
    }
                
        return des;
}
```

* 回来后发现有下面几个问题： 
  1. 函数参数指针类型应该是`void *`型类型，兼容所有类型的数据拷贝
  2. `char *const des` 目标地址不可使用`const`修饰，修饰后指针变量变成只读，函数里边的`des++`会有问题
  3. `char *const res` 原地址应该使用`const char *res` 保证原内存数据不被改变，而不是原内存地址不可变
  4. 函数入口函数校验，没有校验`len`合法性，`len` 应该是大于0的
  5. 内部是一个字节一个字节的复制，效率比较低
  6. 没有考虑内存重叠的问题
总之写的memcpy函数问题比较多，漏洞百出

### 对rt-thread 中memcpy函数的疑问

* rt_memcpy函数的源码

```c
void *rt_memcpy(void *dst, const void *src, rt_ubase_t count)
{
#ifdef RT_USING_TINY_SIZE
    char *tmp = (char *)dst, *s = (char *)src;
    rt_ubase_t len;

if(tmp <= s || tmp > (s + count))
    {
        while (count--)
            *tmp ++ = *s ++;
    }
    else
    {
        for(len = count; len > 0; len --)
            tmp[len -1] = s[len - 1];
    }

return dst;
#else

#define UNALIGNED(X, Y)                                               \
                        (((rt_int32_t)X & (sizeof(rt_int32_t) - 1)) | \
                         ((rt_int32_t)Y & (sizeof(rt_int32_t) - 1)))
#define BIGBLOCKSIZE    (sizeof(rt_int32_t) << 2)
#define LITTLEBLOCKSIZE (sizeof(rt_int32_t))
#define TOO_SMALL(LEN)  ((LEN) < BIGBLOCKSIZE)

char *dst_ptr = (char *)dst;
    char *src_ptr = (char *)src;
    rt_int32_t *aligned_dst;
    rt_int32_t *aligned_src;
    int len = count;

/* If the size is small, or either SRC or DST is unaligned,
    then punt into the byte copy loop.  This should be rare. */
    if (!TOO_SMALL(len) && !UNALIGNED(src_ptr, dst_ptr))
    {
        aligned_dst = (rt_int32_t *)dst_ptr;
        aligned_src = (rt_int32_t *)src_ptr;

/* Copy 4X long words at a time if possible. */
        while (len >= BIGBLOCKSIZE)
        {
            *aligned_dst++ = *aligned_src++;
            *aligned_dst++ = *aligned_src++;
            *aligned_dst++ = *aligned_src++;
            *aligned_dst++ = *aligned_src++;
            len -= BIGBLOCKSIZE;
        }

/* Copy one long word at a time if possible. */
        while (len >= LITTLEBLOCKSIZE)
        {
            *aligned_dst++ = *aligned_src++;
            len -= LITTLEBLOCKSIZE;
        }

/* Pick up any residual with a byte copier. */
        dst_ptr = (char *)aligned_dst;
        src_ptr = (char *)aligned_src;
    }

while (len--)
        *dst_ptr++ = *src_ptr++;

return dst;
#undef UNALIGNED
#undef BIGBLOCKSIZE
#undef LITTLEBLOCKSIZE
#undef TOO_SMALL
#endif
}
```

* 先来描述一下函数中的几个宏定义，看看是否理解上有错误
  1. 宏`UNALIGNED(X, Y)` 用来判断输入的两个值能否被4整除，通过和`sizeof(rt_uint32_t)-1`&计算来判断，地址的后两位是0，表示能被4整除，内存是对齐的，返回0，内存不对齐则返回1；
  2. 宏`BIGBLOCKSIZE` 拷贝大内存块的长度`sizeof(rt_uint32_t)<<2` 表示4左移2位 等于16
  3. 宏`LITTLEBLOCKSIZE` 拷贝小内存块长度`(sizeof(rt_int32_t))` 表示4
  4. `TOO_SMALL(LEN)` 检测长度len的大小，len大于16返回0，否则返回1

* 看完之有个问题：
语句：`if (!TOO_SMALL(len) && !UNALIGNED(src_ptr, dst_ptr))` 根据上下文理解，这句代码的意思是len的长度大于16且内存地址能被4整除，才进行大块的拷贝。为什么要能被4整除呢？函数的内部拷贝16字节后是`len-=BIGBLOCKSIZE`，剩余不足16字节时是`len -= LITTLEBLOCKSIZE`，不足4字节时按照byte拷贝，感觉地址和是不是能被4整除没有关系啊?