实现一些常用字符串处理函数

1、字符串copy函数strcpy，实现如下:

#include <assert.h>
char *mystrcpy(char *dest,const char *sor)//将源字符sor串拷到目的字符串dest
{
	assert(dest);
	assert(sor);
	char *ret = dest;
	while(*dest++ = *sor++)
	{
		;
	}
	return ret;
}

2、判断一个字符串中的子字符串strstr，实现如下：

#include <assert.h>
#include <stdio.h>
char *mystrstr(char *str_one,char *str_two)//判断str_two字符串是不是str_one字符串的子字符                                           //串
{
	char *pstr_one = NULL;
	char *pstr_two = NULL;
	while(*str_one)
	{
		pstr_one = str_one;
		pstr_two = str_two;
		while((*pstr_one)&&(*pstr_one == *pstr_two))
		{
			pstr_one++;
			pstr_two++;
			if(*pstr_two == '\0')
			{
				return str_one;
			}	
		}
		str_one++;
	}
	return NULL;
}

3、三种方法实现求取字符串长度strlen：

#include <assert.h>
//计数器实现strlen
//int mystrlen(const char *dest)
//{
//	assert(dest);
//	int count  = 0;
//	while(*dest)
//	{
//		count++;
//		dest++;
//	}
//	return count;
//}
//指针实现strlen
//int mystrlen(const char *dest)
//{
//	assert(dest);
//	int ret = 0;
//	const char *buff = dest;
//	while(*dest)
//	{
//		dest++;
//	}
//	ret = dest - buff;
//	return ret;
//}
//递归实现strlen
int mystrlen(const char *dest)
{
	assert(dest);
	if(*dest == '\0')
	{
		return 0;
	}
	dest++;
	return 1+mystrlen(dest);
}

4、字符串的比较strcmp，代码如下：

#include <assert.h>
int mystrcmp(const char *cmp1,const char *cmp2)
{
	assert(cmp1);
	assert(cmp2);
	int ret = 0;
	while(!(ret = (*(unsigned char*)cmp1 - *(unsigned char*)cmp2))&&*cmp2)
	{
		cmp1++;
		cmp2++;
	}
	if(ret>0)
		return 1;
	else if(ret<0)
		return -1;
	return 0;
}

5、字符串链接函数strcat，代码如下：

#include <assert.h>
char *mystrcat(char *dest,const char *sor)
{
	assert(dest);
	assert(sor);
	char *ret = dest;
	while(*dest)
	{
		dest++;
	}
	while(*dest++ =*sor++)
	{
		;
	}
	return ret;
}

注意：对于一些特别的符号字符串处理函数就不能很好的解决了，比如要复制或链接两个内容都是'\0'，这样就不能很好解决问题。因此就引入了内存的复制和移动函数。

6、拷贝函数，memcpy函数，有三个参数，两个空类型指针（也叫做句柄）（表示可以接受任何类型的指针），一个count字符串大小。代码如下：

#include <assert.h>
void *mymemcpy(void *dest,const void *sor,int count)
{
	assert(dest);
	assert(sor);
	char *pdest = (char *)dest;
	char *psor = (char *)sor;
	void *ret = dest;
	while(count--)
	{
		*pdest++ = *psor++;
	}
	return ret;
}

注意这个函数的的缺点：导致内容被覆盖：

a

b

c

d

e

f

g

h

i

j

比如：如果不abcd拷贝到cdef，则会导致cd被ab覆盖，输出的结果为：abababghij而不是：ababcdghij

因此引入，memmove函数。

7、memmove函数，拷贝内存函数，很好的解决的memcpy的不足，代码如下:

#include <assert.h>
void *mymemmove(void *dest,const void *sor,int count)
{
	assert(dest);
	assert(sor);
	char *pdest = (char *)dest;
	char *psor = (char *)sor;
	void *ret = dest;
	if(pdest>psor&&pdest<psor+count)//从后向前复制，这样就很好解决了memcpy的覆盖问题
	{
		while(count--)
		{
			*(pdest+count) = *(psor+count);
		}
	}
	else
	{
		while(count--)           
		{
			*pdest++ = *psor++;
		}
	}
	return ret;
}