string函数库的原型

 #ifndef __HAVE_ARCH_STRCPY
 /**
  * strcpy - Copy a %NUL terminated string
  * @dest: Where to copy the string to
  * @src: Where to copy the string from
  */
 char *strcpy(char *dest, const char *src)
 {
         char *tmp = dest;

         while ((*dest++ = *src++) != '\0')
                 /* nothing */;
         return tmp;
 }

char *strcpy

 /**
  * memcpy - Copy one area of memory to another
  * @dest: Where to copy to
  * @src: Where to copy from
  * @count: The size of the area.
  *
  * You should not use this function to access IO space, use memcpy_toio()
  * or memcpy_fromio() instead.
  */
 void *memcpy(void *dest, const void *src, size_t count)
 {
         char *tmp = dest;
         const char *s = src;

         while (count--)
                 *tmp++ = *s++;
         return dest;
 }

void *memcpy

strcpy和memcpy主要有以下3方面的区别。
1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

 #ifndef __HAVE_ARCH_STRCMP
 /**
  * strcmp - Compare two strings
  * @cs: One string
  * @ct: Another string
  */

 int strcmp(const char *cs, const char *ct)
 {
         unsigned char c1, c2;

         while () {
                 c1 = *cs++;
                 c2 = *ct++;
                 if (c1 != c2)
                         return c1 < c2 ? - : ;
                 if (!c1)
                         break;
         }
         return ;
 }

int strcmp

 /**
  * strncmp - Compare two length-limited strings
  * @cs: One string
  * @ct: Another string
  * @count: The maximum number of bytes to compare
  */
 int strncmp(const char *cs, const char *ct, size_t count)
 {
         unsigned char c1, c2;

         while (count) {
                 c1 = *cs++;
                 c2 = *ct++;
                 if (c1 != c2)
                         return c1 < c2 ? - : ;
                 if (!c1)
                         break;
                 count--;
         }
         return ;
 }

int strncmp

 /**
  * strlen - Find the length of a string
  * @s: The string to be sized
  */
 size_t strlen(const char *s)
 {
         const char *sc;

         for (sc = s; *sc != '\0'; ++sc)
                 /* nothing */;
         return sc - s;
 }

size_t strlen

 /**
  * memset - Fill a region of memory with the given value
  * @s: Pointer to the start of the area.
  * @c: The byte to fill the area with
  * @count: The size of the area.
  *
  * Do not use memset() to access IO space, use memset_io() instead.
  */
 void *memset(void *s, int c, size_t count)
 {
         char *xs = s;

         while (count--)
                 *xs++ = c;
         return s;
 }

void *memset

 /**
  * memmove - Copy one area of memory to another
  * @dest: Where to copy to
  * @src: Where to copy from
  * @count: The size of the area.
  *
  * Unlike memcpy(), memmove() copes with overlapping areas.
  */
 void *memmove(void *dest, const void *src, size_t count)
 {
         char *tmp;
         const char *s;

         if (dest <= src) {
                 tmp = dest;
                 s = src;
                 while (count--)
                         *tmp++ = *s++;
         } else {
                 tmp = dest;
                 tmp += count;
                 s = src;
                 s += count;
                 while (count--)
                         *--tmp = *--s;
         }
         return dest;
 }

void *memmove

 /**
  * memcmp - Compare two areas of memory
  * @cs: One area of memory
  * @ct: Another area of memory
  * @count: The size of the area.
  */
 int memcmp(const void *cs, const void *ct, size_t count)
 {
         const unsigned char *su1, *su2;
         int res = ;

         for (su1 = cs, su2 = ct;  < count; ++su1, ++su2, count--)
                 if ((res = *su1 - *su2) != )
                         break;
         return res;
 }

int memcmp