库函数实现（字符和字符串函数 内存操作函数）

字符和字符串函数

自己实现 strlen() 求字符串长度

int Mystrlen(char *p)
{
	int count=0;
	while (*p != NULL)   //遇‘\0’截止
	{
		count++;
		p++;
	}
	return count;
}
int main()
{
	char *str = "abcdef";
	printf("%d\n", Mystrlen(str));
	return 0;
}

自己实现strcpy() 复制字符串

char* Mystrcpy(char *des,  const char*src)
{
	assert(des&&src);  //断言，防止空指针
	char *p = des;
	while (*des++ = *src++);
	return p;
}

int main()
{
	char str[10] = "abc"; //要定义为数组形式，字符串形式是不可修改的
	char* str1 = "11";
	printf("%s\n", Mystrcpy(str, str1));//结果为11
}

自己实现strcat() 拼接字符串

char* mystrcat(char* dest,char* src)
{
	assert(dest);
	if (src == NULL)
	{
		return dest;
	}
	char* p = dest;
	char* start = dest + strlen(dest);  
	while (*start++ = *src++);
	return p;
}

int main()
{
	char str1[10] = "123"; //要定义为数组形式，字符串形式是不可修改的
	char* str2 = "456";
	printf("%s\n", mystrcat(str1, str2));//结果为123456
}

自己实现strcmp() 比较字符串

int Mystrcmp(char* str1,char* str2)
{
	assert(str1&&str2);  //断言，两个字符串都不能为空
	if (str1 == NULL)
		return -1;
	if (str2 == NULL)
		return 1;
	while(*str1==*str2)   //判断字符串开始有相等字符的情况
	{
		if (*str1=='\0')
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)   //判断字符串不相等 
		return 1;
	else
		return -1;
}

int main()
{
	char *str1 = "125";
	char *str2 = "124";
	int ret = Mystrcmp(str1, str2);   
	printf("%d\n", ret);   //结果为1，表示str1大于str2
}

自己实现strstr() 查找子串在主串第一次出现的位置

//字符串查找函数的实现，查找子串第一次在主串出现的位置。
char* Mystrstr(char* str,char* substr)
{
	assert(str&&substr);  
	if (substr == NULL)
		return NULL;
	char* p = str;
	while (*p)
	{
		char* start = p;       
		char* sub = substr;   //每次重新查询都要重新定义sub
		while (start&&sub&&*sub == *start)
		{
//内循环，即出现相同字符后的查询，循环变量不能和外层循环相等
			start++;
			sub++;
		}
		if (*sub == '\0')    
		//此时说明子串所有的字符已经在主串中被找到
			return p;  //返回第一次出现的位置，输出剩余字符串。
		p++;
	}
	return NULL;
}

int main()
{
	char* str = "12343456";
	char* sub = "345";
	char* ret = Mystrstr(str, sub);
	printf("%s\n", ret);     //输出结果3456
}

内存操作函数

自己实现memcpy() 内存复制函数

//内存复制函数,如果内存有重叠，复制的结果都是未定义的
char* Mymemcpy(char* dest,const char* src,int size)
{
	assert(dest&&src);
	if (src == NULL)
		return dest;
	char *p = dest;
	while (size--)
	{
		*dest++ = *src++;
	}
	return p;

}
int main()
{
	char dest[10] = "123456";
	char *src = "789";
	printf("%s\n", Mymemcpy(dest, src, 3));//结果为789456
}

自己实现memmove()

//内存中源位置和目标位置出现重叠,采用memmove函数
char* Mymemmove(char* dest, char* src, int size)
{
	assert(dest&&src);
	if (src == NULL)
		return dest;
	char *p = dest;
	if (src > dest)      //源位置在目标位置之后
	{
		while (size--)
		{
			*dest++ = *src++;
		}
	}
	else              //源位置在目标位置之前       
	{
		for (int i = size; i >= 1; i--)
		{
			*(dest + i - 1) = *(src + i - 1);
		}
	}
	return p;

}
int main()
{
	char dest[10] = "123456";
	printf("%s\n", Mymemmove(dest+2, dest, 3));     //结果为1236
	//两个不能同时输出，前边的改变会影响后边内容的输出。
	//printf("%s\n", Mymemmove(dest, dest+2, 3)); //结果为345456     
}