字符串与内存函数

1.strcat 字符串连接函数，类似于字符串的+=

char* Strcat(char* dest, const char* src) {
	if (dest == NULL || src == NULL) {
		return NULL;
	}
	char* tmp = dest;
	while (*tmp) {
		tmp++;
	}
	int n = 0;
	while (*(src + n)) {
		*(tmp + n) = *(src + n);
		n++;
	}
	*(tmp + n) = '\0';
	return dest;
}

开头要对参数做简单的合法性检验，可以用if语句也可以用断言。要保证dest中有足够大的空间容纳连接之后的字符串，且要包含‘\0’。函数最后不要忘记拷贝‘\0’。返回值为目标字符串的首元素地址。
　　其中关于使用判断语句和断言来排除不合法的情况，要根据实际的场景来选择。断言是条件不成立程序直接奔溃，只适用于致命问题。而判断语句可以做其他的处理，比较灵活。
　　
2.strlen 计算字符串的长度

int Strlen(const char* str) {
	if (str == NULL) {
		return NULL;
	}
	int n = 0;
	for (; *str; str++) {
		n++;
	}
	return n;
}

同样开头做合法性检验。函数的执行在遇到‘\0’时结束。返回值为字符串的长度。

3.strcpy 字符串拷贝函数，类似于字符串的‘=’

char* Strcpy(char* dest, const char* src) {
	if (dest == NULL || src == NULL) {
		return NULL;
	}
	int i = 0;
	while (*(src + i)) {
		*(dest + i) = *(src + i);
		i++;
	}
	*(dest + i) = '\0';
	return dest;
}

同样要在开头做合法性检验，保证其不是野指针NULL。和strcat一样要保证dest中有足够的空间容纳拷贝过来的源字符串，不要忘记最后要拷贝‘\0’。返回值为目标字符串首元素的地址。

4.strstr 求str2在str1第一次出现的位置，若str2不是str1的子串则返回NULL。

const char* Strstr(const char* str1, const char* str2) {
	assert(str1 != NULL && str2 != NULL);
	if (*str2 == '\0' || strlen(str1) < strlen(str2)) {
		return NULL;
	}
	const char* p1 = str1, *p2 = str2, *start = str1;
	while (*start) {
		while (*p2 && *p1) {
			if (*p2 != *p1) {
				break;
			}
			p1++;
			p2++;
		}
		if (*p2 == '\0') {
			return start;
		}
		if (*p1 == '\0') {
			return NULL;
		}
		start++;
		p1 = start;
		p2 = str2;
	}
	return NULL;
}

这里不适合用判断检验参数的合法性，使用断言。从str1的开始扫描后面strlen（str2）个元素看是否与str2中的元素相同。若遇到不相同则从下一个位置重新开始扫描。返回第一次找到子串的位置。

5.strcmp 字符串比较函数，根据ASCCII码值依次比较两个字符串中对应位置的字母，遇到str1大于str2字母则返回一个正数；遇到str1中的某个字母小于str2中同样位置的字母则返回一个负数。若完全相等则返回0.

int Strcmp(const char* str1, const char* str2) {
	assert(str1 != NULL && str2 != NULL);
	while (*str1 && *str2) {
		if (*str1 > *str2) {
			return 1;
		}
		else if (*str1 < *str2) {
			return -1;
		}
		str1++;
		str2++;
	}
	if (*str1 > *str2) {
		return 1;
	}
	else if (*str1 < *str2) {
		return -1;
	}
	return 0;
}

在遇到‘\0’之前依次比较，若遇到‘\0’之前都没有比较出大小结果，则再进行一次比较即可。

6.memcpy 内存拷贝函数，用于从内存中的源地址开始，拷贝若干字节的内容至目标地址处。

void* Memcpy(void* dest, const void* src, size_t num) {
	assert(dest != NULL && src != NULL);
	char* d = (char*)dest;
	char* s = (char*)src;
	for (size_t i = 0; i < num; i++) {
		*(d + i) = *(s + i);
	}
	return dest;
}

参数类型为void*，为了兼容各种类型的指针。返回目标地址。

7.memmove 在使用memcpy拷贝内存中的数据时，有时会出现缓冲区重叠的情况。鉴于此，使用memmove函数，从最后一个字节开始拷贝，保证拷贝有效，但是会导致拷贝之后源地址里的内容发生变化。
缓冲区重叠的情况是：src <dest<src + len

void* Memmove(void* dest, const void* src, size_t num) {
	assert(dest != NULL || src != NULL);
	char* d = (char*)dest, *s = (char*)src;

	if (d > s && d < s + num) {
		char* cd = d + num - 1;
		char* cs = s + num - 1;
		for (size_t i = 0; i < num; i++) {
			*cd = *cs;
			cd--;
			cs--;
		}
	}
	else {
		memcpy(dest, src, num);

	}
	return dest;
}

这里从最后一个字节开始拷贝的代码可能会写成：

		char* d = (char*)dest, *s = (char*)src;
		for (size_t i = num - 1; i >= 0; i--) {
			*(d + i) = *(s + i);
		}

写成下面这种情况会导致未定义行为，即访问了非法指针。原因是i是无符号类型，始终满足循环中大于等于0的条件，再一次–得到了INT_MAX!!所以使用无符号类型的时候要格外当心！！！