1. 模拟实现strlen

#include<stdio.h>

//方法1：计数器方式
int my_strlen(const char * str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

//方法2：不能创建临时变量计数器
int my_strlen(const char * str)
{
  if(*str == '\0')
  return 0;
  else
  return 1+my_strlen(str+1);
}
//方法3：指针-指针的方式
int my_strlen(char *s)
{
char *p = s;
while(*p != ‘\0’ )
p++;
return p-s;
}

2. 模拟实现strcpy

#include<stdio.h>
#include<assert.h>
#include<Windows.h>
//模拟实现strcpy，其中My_strcpy是strcpy函数功能的实现，其余代码是为了看使用效果；
void Print(char *arr, int num)
{
	int i = 0;
	for (i = 0; i < num; i++){
		printf("%c", arr[i]);
	}
	printf("\n");
}
char My_strcpy(const char *src, char *dst)
{
	assert(src);
	assert(dst);
	while (*dst = *src){
		dst++;
		src++;
	}
	return *dst;
}
int main()
{
    const char* src = "hello world!";
	char dst[16];
	My_strcpy(src, dst);
	Print(dst, strlen(dst));
	system("pause");
	return 0;
}

3. 模拟实现strcat

#include<stdio.h>
#include<assert.h>
#include<Windows.h>

//模拟实现strcat

char *my_strcat(char *src,const char *dst)
{
	assert(src);
	assert(dst);
	char *start = src;
	while (*start){//当其不为空自增
		start++;
	}
	while (*start = *dst){//拼接
		start++;
		dst++;
	}
	return src;
}
int main()
{ 
	char src[32] = "please say";
	my_strcat(src, " hello");
	printf("%s\n", src);
	system("pause");
	return 0;
}

4. 模拟实现strstr

#include<stdio.h>
#include<assert.h>
#include<Windows.h>
//模拟实现strstr
const char *my_strstr(const char*str, const char *sub_str)
{
	assert(str);
	assert(sub_str);
	while (*str){//确定初始位置
		const char *p = str;
		const char *q = sub_str;
		while (*p && *q && *p == *q){//局部比较
			p++;
			q++;
		}
		if (*q=='\0'){
			return str;
		}
		str++;
	}
	return NULL;
}
int main()
{
	const char *str = "abc 123 abcd 1234 abcdef";
	const char *sub_str = "1234";
	puts(my_strstr(str, sub_str));
	system("pause");
	return 0;
}

5. 模拟实现strcmp

#include<stdio.h>
#include<assert.h>
#include<Windows.h>
//模拟实现strcmp，其中My_Strcmp是strcmp函数功能的实现，其余代码是为了看使用效果；
void Print(char *arr, int num)
{
	int i = 0;
	for (i = 0; i < num; i++){
		printf("%c", arr[i]);
	}
	printf("\n");
}
int  My_Strcmp(const char *src, const char *dst)
{
	assert(src);
	assert(dst);
	int tmp = 0;
	while (!(tmp = *(unsigned char *)src - *(unsigned char *)dst) && dst)
	{
		++src;
		++dst;
	}
	if (tmp < 0){
		tmp = -1;
	}
	else if (tmp>0){
		tmp = 1;
	}
	return (tmp);
}
int main()
{
	const char* src = "hello world!";
	const char* dst = "hello,world!";
	int res=My_Strcmp(src, dst);
	if (res == 0){
		printf("same\n");
	}
	else{
		printf("different\n");
	}
	system("pause");
	return 0;
}

6. 模拟实现memcpy

#include<stdio.h>
#include<assert.h>
#include<Windows.h>
//模拟实现memcpy
void Print(int *arr, int num)
{
	int i = 0;
	for (i = 0; i < num; i++){
		printf("%d\n", arr[i]);
	}
	printf("\n");
}
void *my_memcpy(void *dst, const void *src, int num)//不能解决内存重叠的问题
{
	assert(src);
	assert(dst);

	char *_dst = dst;
	const char *_src = (const char *)src;//只想用1字节，按照字符串方式访问

	while (num){
		*_dst = *_src;//已经默认空间足够
		_dst++;
		_src++;
		num--;
	}
	return dst;
}
int main()
{
	int a[] = { 1, 2, 3, 4, 5 };
	int b[10] = { 0 };
	my_memcpy(b, a, sizeof(a));
	Print(b, 5);
	system("pause");
	return 0;
}

7. 模拟实现memmove

#include<stdio.h>
#include<assert.h>
#include<Windows.h>
//模拟实现memmove
void Print(char *arr, int num)
{
	int i = 0;
	for (i = 0; i < num; i++){
		printf("%c", arr[i]);
	}
	printf("\n");
}
void *my_memmove(void *dst, const void *src, int num)
{
	assert(src);
	assert(dst);

	char *_dst = dst;
	const char *_src = (const char *)src;

	if (_dst > _src && _dst < _src + num){//从右向左拷贝
		_dst = _dst + num - 1;
		_src = _src + num - 1;
		while (num){
			*_dst = *_src;
			_dst--;
			_src--;
			num--;
		}
	
	}
		while (num){
			*_dst = *_src;
			_dst++;
			_src++;
			num--;
		}
	return dst;
}
int main()
{
	char buf[16] = "abcd1234";
	char *res1 = my_memmove(buf + 1, buf, strlen(buf) + 1);//注意看区别
	char *res2 = my_memmove(buf, buf + 1, strlen(buf) + 1);
	Print(res1, strlen(res1));
	Print(res2, strlen(res2));
	system("pause");
	return 0;
}