一、常见的String封装函数

1. strcpy函数的实现

char *strcpy(char *dest, const char *src)
{char *tmp = dest;while ((*dest++ = *src++) != '\0')/* nothing */;return tmp;
}

2. strncpy函数的实现

char *strncpy(char *dest, const char *src, size_t count)
{char *tmp = dest;while (count) {if ((*tmp = *src) != 0)src++;tmp++;count--;}return dest;
}

3. strcat函数的实现

char *strcat(char *dest, const char *src)
{char *tmp = dest;while (*dest)dest++;while ((*dest++ = *src++) != '\0');return tmp;
}

4. strncat函数的实现

char *strncat(char *dest, const char *src, size_t count)
{char *tmp = dest;if (count) {while (*dest)dest++;while ((*dest++ = *src++) != 0) {if (--count == 0) {*dest = '\0';break;}}}return tmp;
}

5.  strcmp函数的实现

int strcmp(const char *cs, const char *ct)
{unsigned char c1, c2;while (1) {c1 = *cs++;c2 = *ct++;if (c1 != c2)return c1 < c2 ? -1 : 1;if (!c1)break;}return 0;
}

6.  strncmp函数的实现

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 ? -1 : 1;if (!c1)break;count--;}return 0;
}

7.  strlen函数的实现

size_t strlen(const char *s)
{const char *sc;for (sc = s; *sc != '\0'; ++sc)/* nothing */;return sc - s;
}

8.  strnlen函数的实现

size_t strnlen(const char *s, size_t count)
{const char *sc;for (sc = s; count-- && *sc != '\0'; ++sc)/* nothing */;return sc - s;
}

9.  memset函数的实现

void *memset(void *s, int c, size_t count)
{char *xs = s;while (count--)*xs++ = c;return s;
}

10.  memcpy函数的实现

void *memcpy(void *dest, const void *src, size_t count)
{char *tmp = dest;const char *s = src;while (count--)*tmp++ = *s++;return dest;
}

二、内存重叠问题

memcpy函数将src的字节数复制到dest。如果源和目标重叠，这个函数不能确保重叠区域的原始源字节在被覆盖之前被复制。

一. 高地址向低地址进行拷贝
由于在虚拟地址空间中，栈空间的生长方向是高地址向低地址生长，首先采用这种方式。简略的讲就是源字符串中的字符从前往后向目标字符串按给定字节的大小依此进行拷贝。
观察上图，可以得到两个合理的区间即不会出现内存覆盖的区间。
(1)dest<=src

第一种情况dest=src,此时源字符串与目标字符串指针指向同一个位置，拷贝的过程相当自己给自己赋值，因此拷贝结束 后源字符串并没有发生变化。

第二种情况dest < src,这样的拷贝尽管会覆盖src的内容，出现了内存重叠，但其可以完成内存拷贝的功能，并没有将错误的信息拷贝过来。

(2)dest>=src+n
当dest>=src+n，无论如何都不会出现内存重叠的问题。

二. 低地址向高地址拷贝
(3)src<dest<src+n (内存重叠)
为了避免出现这种情况，我们可以将src和dest都移动 n-1个位置，这样我们就可以从地址值向高地址进行拷贝，这样尽管也有可能目标字符串覆盖源字符串的情况，但是定影可以得到一个正确的拷贝。

1. memove可以避免内存拷贝时的重叠问题。
2. 实际上，memcpy只是memmove的一个子集。
3. memcpy比memmove的速度要快一些。

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;
}