1、memset

函数原型：void *memset(void *s, int ch, size_t n);

函数解释：将s中前n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。

void* memset(void* s, int ch, size_t count)
{
	assert(s!=NULL);
	char* p = (char*)s;
	while (count--)
	{
		*p++ = ch;
	}
	return s;
}

2、memcpy

函数原型：void *memcpy(void *dest, const void *src, size_t n);

功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中

void* memcpy(void* p1,const void* p2, size_t count)
{
	assert(p1 != NULL || p2 != NULL);
	char* dst = (char*)p1;
	char* src = (char*)p2;
	while (count--)
	{
		*dst++ = *src++;
	}
	return p1;
}

3、memove

函数原型：void *memmove( void* dest, const void* src, size_t count );

功能：memmove用于从src拷贝count个字符到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。但复制后src内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同

void* memove(void* p1, const char* p2, size_t count)
{
	assert(p1 == NULL || p2 == NULL);
	char* dst = (char*)p1;
	const char* src = (const char*)p2;
	if ((dst > src) && (dst < src + count))
	{
		//while (count--)
		//{
		//	*dst = *src;
		//	dst++;
		//	src++;
		//}//以上写法是错误的
		dst = dst + count - 1;
		src - src + count - 1;
		while (count--)
		{
			*dst = *src;
			dst--;
			src--;
		}
	}
	else
	{
		while (count--)
		{
			*dst = *src;
			dst++;
			src++;
		}
	}
	return dst;
}

4、memcmp

原型：int memcmp(const void *buf1, const void *buf2, unsigned int count);

功能：比较内存区域buf1和buf2的前count个字节。

说明：当buf1<buf2时，返回值<0　

           当buf1=buf2时，返回值=0　

           当buf1>buf2时，返回值>0

int memcmp(const void* p1,const void* p2, size_t count)
{
	assert(p1 != NULL&&p2 != NULL);
	int ret = 0;
	const char* src = (const char*)p1;
	const char* dst = (const char*)p2;
	if (count == 0)
	{
		return 0;
	}
	while (--count&&*src == *dst)
	{
		src++;
		dst++;
	}
	return (*((unsigned char*)src) - *((unsigned char*)dst));

}

5、strcpy

原型声明：char *strcpy(char* dest, const char *src);

功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。

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

6、strncpy

函数原型char*strncpy(char*dest,char*src,size_tn);

功能：（c/c++）复制字符串src中的内容（字符，数字、汉字....）到字符串dest中，复制多少由size_tn的值决定。

1）src串长度<=dest串长度,(这里的串长度包含串尾NULL字符)

如果n>src由于长度达到src NULL，正常复制，特别注意，如果src中有NULL，strncpy复制到NULL即使没到n也提前停止。如果n = src串长度，与strcpy一致。注意n的选择当n > dest串长度，dest栈空间溢出产生崩溃异常。

2）src串长度>dest串长度

如果n =dest串长度，则dest串没有NULL字符，会导致输出会有乱码。如果不考虑src串复制完整性，可以将dest 最后一字符置为NULL。



char* strncpy(char* dst, const char* src, size_t count)

{

assert(dst != NULL&&src != NULL);

char* start = dst;

while (count && (*dst++ = *src++) != '\0')

{

count--;

}

if (count)

{

while (count--)

{

*dst++ = '\0';

}

}

return start;

}

7、strcat

函数原型extern char *strcat(char *dest,char *src);

功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')。

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。

char* strcat(char* dst, const char* src)
{
	assert(dst != NULL || src != NULL);
	char* start = dst;
	while (*dst)
	{
		dst++;
	}
	while (*dst++ = *src++)
		;
	return start;
}

8、strncat

函数原型：char * strncat(char *dest, const char *src, size_t n);

【参数说明】：dest指向目标字符串，src为指向源字符串。

功能：把src所指字符串的前n个字符添加到dest所指字符串的结尾处，并覆盖dest所指字符串结尾的'/0'，从而实现字符串的连接。

说明：src和dest所指内存区域不可以重叠，并且dest必须有足够的空间来容纳src的字符串。

返回值：返回指向dest的指针。

char* strncat(char* dst, const char* src, size_t count)
{
	assert(dst != NULL && src != NULL);
	char* start = dst;
	while (*dst++)
		;
	dst--;
	while (count--)
	{
		if (!(*dst++ = *src++))
			return start;
	}
	*dst = '\0';
	return start;
}

9、strcmp

函数原型：extern int strcmp(const char *s1,const char *s2);

说明：

当s1<s2时，返回为负数；

当s1=s2时，返回值= 0；

当s1>s2时，返回正数。

即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止

int strcmp(const char* src, const char* dst)
{
	assert(dst != NULL&&src != NULL);
	int ret = 0;
	while (!(ret = *(unsigned char*)src - *(unsigned char*)dst) && *dst)
	{
		++src;
		++dst;
	}
	if (ret < 0)
	{
		ret = -1;
	}
	else if (ret>0)
	{
		ret = 1;
	}
	return ret;
}

10、strncmp

函数原型：int strncmp ( const char * str1, const char * str2, size_t num );

功能：strncmp函数是指定比较size个字符。也就是说，如果字符串s1与s2的前size个字符相同，函数返回值为0。此函数功能即比较字符串str1和str2的前maxlen个字符。如果前maxlen字节完全相等，返回值就=0；在前maxlen字节比较过程中，如果出现str1[n]与str2[n]不等，则依次比较str1和str2的前n位，设i(i<n)为两字符串首次的不同位，则返回（str1[i]-str2[i]

int strncmp(const char* dst, const char* src, size_t count)
{
	assert(dst != NULL || src != NULL);
	if (count==0)
	{
		return 0;
	}
	while (--count&&*dst&&*dst == *src)
	{
		dst++;
		src++;
	}
	return (*(unsigned char*)dst - *(unsigned char*)src);
}

11、strchr

函数原型：extern char *strchr(const char *s,char c);

功能：查找字符串s中首次出现字符c的位置

说明：返回首次出现c的位置的指针，返回的地址是被查找字符串指针开始的第一个与Val相同字符的指针，如果s中不存在c则返回NULL。

返回值：成功则返回要查找字符第一次出现的位置，失败返回NULL

char* strchr(const char* str, int ch)
{
	assert(str!=NULL);
	while (*str&&*str != (char)ch)
	{
		str++;
	}
	if (*str == ch)
		return (char*)str;
	return NULL;
}

12、strlen

函数原型：extern unsigned int strlen(char *s）;

功能：计算给定字符串的（unsigned int型）长度，不包括'\0'在内

说明：返回s的长度，不包括结束符NULL。

int strlen(const char* str)
{
	assert(str != NULL);
	int count;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int strlen(const char* str)
{
	assert(str != NULL);
	const char* p = str;
	while (*p++)
	{
		p++;
	}
	return (int)(p - str - 1);
}
int strlen(const char* str)
{
	assert(str != NULL);
	if (*str == '\0')
	{
		return 0;
	}
	else
	{
		return strlen(str++) + 1;
	}
}

13、

char* strstr(const char* str1, const char* str2)
{
	assert(str1 != NULL&&str2 != NULL);
	const char* p = str1;
	const char* s1 = p;
	const char* s2 = NULL;
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while (*s1&&*s2&&*s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)p;
		}
		p++;
	}
	return NULL;
}