一、常见的String封装函数

1. strcpy函数的实现

char *strcpy(char *dest, const char *src)
{
	char *tmp = dest;

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

注意：strcpy 函数的返回值类型为 char*，即目标字符串的起始地址，主要有以下两个原因：

方便链式表达式：通过返回目标字符串的指针，可以方便地在连续的字符串操作函数中进行链式调用。比如可以将 strcpy 与其他字符串操作函数（如 strcat）连续使用，如 result = strcpy(dest, src1); result = strcat(result, src2);。这样可以在一行代码中完成多个字符串拷贝和连接的操作。
返回传入的目标指针：strcpy 函数在内部会修改目标字符串指针 dest 的值，使其指向复制后的字符串的结尾位置。通过返回目标字符串的起始地址，可以方便地获取复制后的字符串，并进行后续的操作或验证。

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个位置，这样我们就可以从地址值向高地址进行拷贝，这样尽管也有可能目标字符串覆盖源字符串的情况，但是定影可以得到一个正确的拷贝。

memove可以避免内存拷贝时的重叠问题。
实际上，memcpy只是memmove的一个子集。
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;
}

String底层函数的实现方式