内存函数来喏~

在讲内存函数之前，补上之前有关字符分类的函数：

函数                                如果他的参数复合下列条件就返回真

iscntrl                              任何控制字符

isspace                           空白字符：空格，换页，回车，制表符，垂直制表符

isdigit                              十进制数字0~9

isxdigit                            十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F

islower                            小写字母a~z

isupper                           大写字母A~Z

isalpha                            字母a~z或A~Z

isalnum                           字母或者数字，a~z，A~Z，0~9

ispunct                            标点符号，任何不属于数字或者字母的图形字符（可打印）

isgraph                            任何图形字符

isprint                               任何可打印字符，包括图形字符和空白字符

那么接下来到我们的内存函数闪亮登场：

1.memcpy

void * memcpy (void * destination, consr void * source, size_t num );

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置

这个函数在遇到'\0'的时候不会停下来。

如果source和destination有任何的重叠，复制的结果都是未定义的

那么我们开始模拟实现它吧：

void * memcpy ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
  assert(dst);
  assert(src);
  /*
   * copy from lower addresses to higher addresses
   */
  while (count--) {
    *(char *)dst = *(char *)src;
    dst = (char *)dst + 1;
    src = (char *)src + 1;
  }
 
  return(ret);
}

2.memmove

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

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的

如果源空间和目标空间重叠，就得使用memmove函数处理

那么我们开始实现它：

void * memmove ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
​
  if (dst <= src || (char *)dst >= ((char *)src + count)) {
    /*
    * Non-Overlapping Buffers
    * copy from lower addresses to higher addresses
    */
    while (count--) {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
   }
 }
  else {
    /*
    * Overlapping Buffers
    * copy from higher addresses to lower addresses
    */
    dst = (char *)dst + count - 1;
    src = (char *)src + count - 1;
​
    while (count--) {
        *(char *)dst = *(char *)src;
        dst = (char *)dst - 1;
        src = (char *)src - 1;
   }
 }
​
  return(ret);
}

3.memcmp

int memcpy( const void * ptr1, const void * ptr2, size_t num);

比较从ptr1和ptr2指针开始的num个字节。

memcmp ()首先将s1 第一个字符值减去s2 第一个字符的值，若差为0 则再继续比较下个字符，若差值不为0 则将差值返回

那么实现它！！！：

int my_memcmp(char *str1,char *str2,int len)
{
	assert(str1);
	assert(str2);
	while(len--)
	{
	while(*str1==*str2)
	{
		if(*str1=='\0')
			return 0;
	
			str1++;
			str2++;
	
	}
	}
	if(*str1>*str2)
		return 1;
	if(*str1<*str2)
		return -1;
}