C实现常用字符串库函数

系列文章目录

一、实现memcpy

将src所指向的内容拷贝到dst所指向的位置，拷贝len个字节。

• memcpy是内存拷贝函数
• memcpy在使用的时候不用考虑类型，以字节为单位进行拷贝
• 遇到"\0"的时候不会停下，所以拷贝字符串的时候最好还是用strcpy，它更安全。

void *Mymemcpy(void * dst, const void * src, int len){
    
    
	void *ret = dst;
	assert(src);
	assert(dst);
	while (len--){
    
    
		*(char *)dst = *(char *)src;
		dst = (char *)dst + 1;
		src = (char *)src + 1;
	}
	return ret;
}
int main(){
    
    
	char str[100] = "ABCDE";
	Mymemcpy(str, str + 2, 2);
	printf("%s", str);
	system("pause");
	return 0;
}

但是当我们修改了测试用例后发现了如下结果

出现这种情况的原因很简单，因为我们源字符串的首地址低于目标字符串的首地址，当我们默认从左向右拷贝的时候第一个字符串会覆盖第二个字符串，所以出现了全A的情况，这就是内存重叠拷贝，要解决这个问题非常简单，只需要在拷贝之前加一个判断，如果源字符串的首地址低于目标字符串的首地址则我们从右向左拷贝，这样就可以完美解决这个问题。

二、memmove模拟实现

这里我们重复刚才的测试用例，发现加入了判断并从右向左拷贝了之后没有出现全A的情况。

void * Mymemmove(void * dst, const void *src, int len){
    
    

	char *_src = (char*)src;
	char *_dst = (char*)dst;
	if (_dst > _src&&_dst < _src + len){
    
    
		_dst = _dst + len - 1;
		_src = _src + len - 1;

		while (len--){
    
    
			*_dst = *_src;
			_dst--;
			_src--;
		}
	}
	else {
    
    
		while (len--){
    
    
			*_dst = *_src;
			_dst++;
			_src++;
		}
	}
	return dst;
}
int main(){
    
    
	char str[100] = "ABCDE";
	int len = strlen(str);
	memcpy(str+1, str , len);
	printf("%s", str);
	system("pause");
	return 0;
}

三、strlen的模拟实现

1.计数器方法：

int Mystrlen(char * str){
    
    
	int count = 0;
	while (*str != 0){
    
    
		str++;
		count++;
	}
	return count;
}
int main(){
    
    
	char a[] = "dadai";
	int aa=Mystrlen(a);
	printf("%d", aa);
	system("pause");
	return 0;
}

2.递归方式：

int Mystrlen(char * str){
    
    
	if (*str == '\0'){
    
    
		return 0;
	}
	else return (1 + Mystrlen(str + 1));
}//1+1+1+1+1+0
int main(){
    
    
	char a[] = "dadai";
	int aa=Mystrlen(a);
	printf("%d", aa);
	system("pause");
	return 0;
}

3.利用指针实现：

int Mystrlen(char * str){
    
    
	char *p = str;
	while (*p){
    
    
		p++;
	}
	return (p - str);
}

int main(){
    
    
	char a[] = "dadai";
	int aa=Mystrlen(a);
	printf("%d", aa);
	system("pause");
	return 0;
}

四、strcpy的模拟实现

将src所指向的内容拷贝到dst所指向的存储单元。

char * Mycpy(char *dst, const char * src){
    
    
assert(dst != NULL && src !=NULL);
char *Mycpy = dst;
while((*dst++ = *src++) != '\0');
return Mycpy;
}
int main(){
    
    


	char src []= "daadok";
	char dst[10] ;
	Mycpy(dst, src);
	printf("%s", dst);
	system("pause");
	return 0;
}

五、strcmp的模拟实现

strcmp用于比较两个字符串是否相等，若相等则返回0，若dst>src则返回1，否则换回-1.

int Mystrcmp(const char* dst,const char * src){
    
    
	while (*dst&&*src&&(*dst == *src)){
    
    
		dst++;
		src++;
	}
	if (*dst > *src){
    
    
		return 1;
	}
	else if (*dst < *src){
    
    
		return -1;
	}
	else if (*dst == *src){
    
    
		return 0;
	}
}
int main(){
    
    
	char str1[] = "abcdefg";
	char str2[] = "dfd";
	int a=Mystrcmp(str1, str2);;
	printf("%d", a);
	system("pause");
	return 0;
}

六、strstr模拟实现

在dst中找到第一次与src相等的位置并输出这个位置之后dst所指向的内容。

char *mystrstr( const char *dst,const  char *src){
    
    
	assert(dst);
	assert(src);
	const char *p = dst;
	while (*p){
    
    
		const char *movep = p;
		const char *sp = src;
		while(*movep && *sp&& *sp== *movep){
    
    
			sp++;
			movep++;
		}
		if (*sp == '\0'){
    
    
			return (char *)p;
		}
		p++;
	}
	return NULL;
}
int main(){
    
    
	const char* dst = "abcd123456";
	const char*src = "cd";
	char *ret= mystrstr(dst, src);
	printf("%s", ret);
	system("pause");
	return 0;
}

七、模拟实现strcat

把src所指向的内容拼接到dst所指向内容的末尾。

char * mystrcat(char*dst, const char*src){
    
    
	assert(src);
	assert(dst);
	char*ret = dst;
	while (*dst){
    
    
		dst++;
	}
	while (*src){
    
    
		*dst = *src;
		dst++; src++;
	}
	return ret;
}
int main(){
    
    
	char dst[64] = "abcd";
	char *src = "efg";
	mystrcat(dst, src);
	printf("%s", dst);
	system("pause");
	return 0;
}