字符串函数和内存函数

一.字符串函数：

1.strcpy:(char* strcpy(char* destination, char* source))

（1）使用：

第一个参数：拷贝的数组，第二个参数：被拷贝的字符串，返回值为一个char*类型的字符指针。

（2）模拟实现：

char* my_strcpy(char* dest, const char* sor)
{
	assert(dest && sor);
	char* ret = dest;
	while (*dest++ == *sor++)
	{
		;
	}
	return ret;
}

2.strcmp:(int strcmp(const char* str1, const char* str2))

（1）使用：

第一个参数：字符串1，第二个参数：字符串2，返回值：int

（2）模拟实现：

int my_strcmp(const char* str1, const char* str2)
{
	while (*str1 != '\0' && *str2 != '\0')
	{
		if (*str1 != *str2)
		{
            //不相等
			return *str1 - *str2;
		}
		str1++;
		str2++;
	}
    //返回为0，则表示字符串相等
	return 0;
}

3.strcat:(char* strcat(char* destination, char* source))

（1）使用：

第一个参数：目标字符串，第二个参数：源字符串，返回值：char*类型的指针

ps：目标空间必须足够大，目标字符串和源字符串必须以'\0'结束。

（2）模拟实现：

char* my_strcat(char* dest, char* sor)
{
	char* ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *sor++)
	return ret;
}

4.strncpy:(char* strcpy(char* destination, char* source, size_t num))

（1）使用：

对source字符串的前num个字符进行拷贝，拷贝到destination字符串中去

（2）模拟实现：

char* my_strncpy(char* dest, const char* sor, size_t num)
{
    //判断dest和sor是否为空指针，如果为则断言报错
	assert(dest && sor);
	char* ret = dest;
	while (num--)
	{
		*dest = *sor;
		dest++;
		sor++;
	}
	return ret;
}

（3）效果实现：

5.strncmp:(int strcmp(const char* str1, const char* str2, size_t num))

（1）使用：

比较str1和str2字符串的前num个字符，看是否相等。

（2）模拟实现：

int my_strncmp(const char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	while (num--)
	{
		if (*str1 != *str2)
		{
			return *str1 - *str2;
		}
		str1++;
		str2++;
	}
    //返回0表示相等，否则不相等
	return 0;
}

（3）效果实现：

6.strncat:(char* strcat(char* destination, char* source, size_t num))

（1）使用：

将源字符串的前num个字符拼接到目的字符串中'\0'的后面（包括'\0'）,会在拼接完成后默认加上'\0'

（2）模拟实现：

char* my_strncat(char* dest, const char* sor, size_t num)
{
	char* ret = dest;
	assert(dest && sor);
	while (*dest)
	{
		dest++;
	}
	while (num--)
	{
		*dest++ = *sor++;
	}
	*dest = '\0';
	return ret;
}

（3）效果实现：

7.strstr:(char* strstr(char* destination, char* source, size_t num))

（1）使用：

在目标字符串中找源字符串出现的第一次位置，并且返回从该位置开始后面所以得字符串内容。

（2）模拟实现：

 

char* my_strstr(const char* str1, const char* str2)
{
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* cur = str1;
	if (str2 == NULL)
	{
		return (char*)str1;
	}
	while (*cur != '\0')
	{
		s1 = cur;
		s2 = str2;
		//*s1=='\0'就是在这个字符串中找不到相对应的字符串
		//*s2=='\0'就是代表已经匹配成功（已成功找到）需要跳出循环
		while (*s1 == *s2 && *s2 != '\0' && *s1 != '\0')
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			//const char*也是一种类型，而返回类型为char*，所以需要强制转换
			return (char*)cur;
		}
		cur++;
	}
	return (char*)NULL;
}

（3）效果实现：

没找到，返回空指针。

找到，返回找到位置后面的所以内容

 

8.strtok:(char* strtok(char* str1, char* str2))

（1）使用：

字符串分割，按照str2字符串中的符号对str1字符串进行分割

（2）效果实现：

ps:打印的时候，只需要传一次ret，后面只需要在传NULL就可以找到上次分割后的位置。

 二.内存函数：

1.memmove:(void* memmove(void* des, void* sor, size_t num))

（1）使用：

将sor字符串向后num个字节移动到des字符串中去。

（2）模拟实现：

void* my_memmove(void* des, void* sor, size_t num)
{
	void* ret = des;
	if (des >= sor)
	{
		//从后向前拷贝
		des = (char*)des + num - 1;
		sor = (char*)sor + num - 1;
		while (num--)
		{
			*(char*)des = *(char*)sor;
			des = (char*)des - 1;
			sor = (char*)sor - 1;
		}
	}
	else
	{
		//从前向后拷贝
		while (num--)
		{
			*(char*)des = *(char*)sor;
			des = (char*)des + 1;
			sor = (char*)sor + 1;
		}
	}
	return ret;
}

（3）效果实现：

2.memcpy:(void* memcpy(void* des, void* sor, size_t num)) 

（1）使用：

将sor字符串向后num个字节拷贝到des字符串中去。

（2）模拟实现：

void* my_momcpy(void* des, void* sor, size_t num)
{
	while (num--)
	{
		*(char*)des = *(char*)sor;
		des = (char*)des + 1;
		sor = (char*)sor + 1;
	}
}

3.memset:(void* memcpy(void* str, void value, size_t num)) 

（1）使用：

将str字符串向后num个字节赋值成value。

（2）效果实现：

4.memcmp:(int memcmp(void* str1, void* str2, size_t num))

（1）使用：

将str1和str2的前num个字节进行判断，并进行比较。

（2）效果实现：