字符串函数的模拟实现

strlen
size_t strlen ( const char * str );
字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
参数指向的字符串必须要以 ‘\0’ 结束。
注意函数的返回值为size_t，是无符号的。

#include<stdio.h>
#include<assert.h>
int my_strlen(const char* str){
	int count = 0;
	assert(str != NULL);
	while (*str != '\0'){
		count++;
		str++;
	}
	return count;
}
int main(){
	int ret = 0;
	char arr[10] = "hello";
	ret = my_strlen(arr);
	printf("%d\n", ret);
	return 0;
}

strcpy
char* strcpy(char * destination, const char * source );
源字符串必须以 ‘\0’ 结束,会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。

#include<stdio.h>
void my_strcpy(char arr[], char brr[], int n){
	for (int i = 0; i <= n; i++){
		arr[i] = brr[i];
	}
}
int main(){
	char arr[100];
	char brr[] = "hello";
    int n = strlen(brr);
	my_strcpy(arr, brr, n);
	printf("%s\n", arr);
	return 0;
}

strcmp
int strcmp ( const char * str1, const char * str2 );
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp(const char* dest, const char* src)
{
	assert(dest != NULL);
	assert(src != NULL);
	int ret = 0;
	while (!(ret = *(unsigned char*)dest - *(unsigned char*)src) && *src){
		++dest;
		++src;
	}
	if (ret < 0) {
		ret = -1;
	}
	else if (ret > 0) {
		ret = 1;
	}
	return  ret;
}
int main() {
	char str1[1024] = { 1,2,3,4,5 };
	char str2[1024] = { 1,2,3,4 };
	int ret = my_strcmp(str1, str2);
	printf("%d\n", ret);
	return 0;
}

strstr
char * strstr ( const char *, const char * );
返回指向str1中首次出现的str2或null的指针。

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
char* my_strstr(const char* dest, const char* src){
	char* start = (char*)dest;//在这里需要强制类型转换成char*
	char* substart = (char*)src;
	char* cp = (char*)dest;//cp就是用来保存首地址的
	assert(dest != NULL);
	assert(src != NULL);
	while (*cp)	{
		start = cp;
		while (*start != '\0' && *substart != '\0' && *start == *substart{
			start++;
			substart++;
		}
		if (*substart == '\0')	{
			return cp;
		}
		substart = (char*)src;
		cp++;//cp++可以得到原起始位置的下一个位置	
		}
	return NULL;
}
int main(){
	char a[20] = "abbbcdef";
	char b[10] = "bbcde";
	printf("%s\n", my_strstr(a, b));
	return 0;
}

memcpy
void * memcpy ( void * destination, const void * source, size_t num );
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memcpy(void* dest, void* src, size_t num){
	assert(dest != NULL);
	assert(src != NULL);
	char* d = (char*)dest;
	char* s = (char*)src;
	while (num)	{
		*d++ = *s++;
		--num;
	}
	return dest;
}
struct {
	char name[40];
    int age;
}person,person_cpy;
int main()
{
	char str[] = "my name is sock";
	my_memcpy(person.name, str, strlen(str) + 1);
	person.age = 20;
	my_memcpy(&person_cpy, &person, sizeof(person));
	printf("%s  %d\n", person_cpy.name, person_cpy.age);
	return 0;
}

memmove
void * memmove ( void * destination, const void * source, size_t num );
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
比较从ptr1和ptr2指针开始的num个字节.