字符串函数与内存操作函数总结与模拟实现

字符串函数

1.strlen 函数

(1)作用：用于求字符串长度，在遍历字符串时遇到 ‘\0’ 停止

(2)函数原型：size_t strlen ( const char* str)

注意事项：strlen的返回值是无符号整型，所以不能轻易比较大小

模拟实现：计数器、递归、指针相减三种方法

                                           计数器方法

int my_strlen(char* str)
{
	assert(str);     //断言，避免str是空指针    
	int count = 0;   //创建计数器
	while (*str++)
	{
		count++;
	}
	return count;
}
int main()
{
	char ch[] = "abcde";
	int sz = my_strlen(ch);
	printf("%d\n", sz);
	return 0;
}

                                              函数递归

int my_strlen(char* str)
{
	if (*str)      //不是'\0' 就继续递归
		return 1 + my_strlen(str + 1);
	else           //直到'\0'返回0值
		return 0;   
}
int main()
{
	char ch[] = "abcde";
	int sz = my_strlen(ch);
	printf("%d\n", sz);
	return 0;
}

                                            指针-指针

int my_strlen(char* str)
{
	char* start = str;
	
	while (*str)
	{
		str++;              //找到'\0'
	}
	return str - start;     //指针-指针得到的是两指针之间的元素个数
}

int main()
{
	char ch[] = "abcdef";
	int sz = my_strlen(ch);
	printf("%d\n", sz);
	return 0;
}

2. strcpy 函数

(1)作用：用于字符串拷贝，拷贝包括 ‘\0’

(2)函数原型：char* strcpy ( char* Dest , char* Sourse )

注意事项：目标空间必须足够大，且可修改。Sourse（源头）必须有 '\0’

模拟实现：

void my_strcpy(char* dest, char* src)
{
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	*dest = *src;      //赋值'\0'
}
int main()
{
	char arr1[20];
	char arr2[] = "abcdef";
	my_strcpy(arr1, arr2);
	printf("%s", arr1);
	return 0;
}

                                             升级版

char* my_strcpy(char* dest, const char* src)     //const修饰src，使得src指向的内容不能发生改变
{
	assert(dest);                         //断言
	assert(src);                     // *****assret(dest && src)******
	char* ret = dest;
	while (*dest++ = *src++)         //（）里的结果为赋值的内容。如*src=='\0' 则表达式的结果为0，循环停止
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20];
	char arr2[] = "abcde";
	char* pa = my_strcpy(arr1, arr2);
	printf("%s", pa);
	return 0;
}

3. strcat 函数

(1)作用：用于字符串末尾的追加，从Dest的 ‘\0’ 开始，追加时源头的’\0’也追加

(2)函数原型：char* strcat ( char* Dest , const char* Source)

注意事项：
（1）目标空间足够大，可修改，目标、源头字符串必须有‘’\0’
（2）不能直接自己追加自己。（函数接受的地址相同）

模拟实现：

char* my_strcat(char* dest, char* src)  //char* dest需要链接的字符串
                                        //char* src链接的内容字符串
{
	assert(*src && *dest);
	char* ret = dest;
	//找到目标空间的'\0'
	while (*++dest)
	{
		;
	}
	//开始追加
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}


int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	printf("%s",my_strcat(arr1, arr2));
	return 0;
}

3. strcmp 函数

(1)作用：字符串比较，比较的是字符串中对应位置的ASCLL码，而不是字符串的大小。若串1>串2，返回大于零的数；若相等返回0；若小于返回小于零的数

(2)函数原型：int strcmp( const char* str1 , const char* str2 )

注意事项：
（1）目标空间足够大，可修改，目标、源头字符串必须有‘’\0’
（2）不能直接自己追加自己。（函数接受的地址相同）

模拟实现：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;                     //++要放在if后面
		str2++;
	}
	if (*str1 > *str2)
		return 1;                //大于返回1
	else
		return -1;               //小于返回-1
}

int main()
{
	int ret = my_strcmp("abc", "abcd");
	printf("%d\n", ret);
	return 0;
}

内存操作函数

1.memcpy 函数

(1)作用：用于内存块中内容的拷贝，操作单位是字节

(2)函数原型：void* my_memcpy(void* dest, const void* src, size_t count)

*注意事项：
（1）一般用于不相干的内存之间内存拷贝，比如将一个数组的内容拷贝到另一个数组
（2）由于设计函数时，不知道需要拷贝的数据类型，所以在参数列表中，指针类型为void
（3）在函数的实现中，由于操作对象为字节，所以将指针的类型强制转换为char*类型，便于一个一个字节内容的拷

模拟实现：

void* my_memcpy(void* dest, const void* src, size_t count)  //void*dest拷贝的目的地  
                                                            //cosnt void*src拷贝的源头 
                                                            // size_t count拷贝的字节数 
{
	assert(src&&dest);
	void* ret = (char*)dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return ret;
}



int main()
{
	char arr1[] = "abc";
	char arr2[20] = { 0 };
	my_memcpy(arr2, arr1,4);
	printf("%s", arr2);
	return 0;
}

2.memmove 函数

(1)作用：用于内存块中内容的拷贝，单位是字节

(2)函数原型：void* my_memmove(void* dest, const void* src, size_t count)

注意事项：
memmove与memcpy的联系与区别：
（1）区别：memcpy主要是用于不同内存块中字节内容的拷贝，而memmove可以称之为memcpy的升级版，拷贝内容不局限于同一内存块。
（2）联系：在某些编译器中，memcpy具有与memmove完全相同的功能，不再局限于同一内存单元的内容拷贝

在模拟实现memmove之前，我们必须清楚的直到造成memcpy与memmove函数功能不相同的原因：

模拟实现：

void* my_memmove(void* dest, const void* src, size_t count)
{
	void* ret = dest;
	assert(dest&&src);
	if (dest < src)
	{
		//从前向后拷贝
		while (count--)
		{
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
	}
	else
	{
		//从后向前拷贝
		while (count--)
		{
			*((char*)dest + count) = *((char*)src+count);
		}
	}
	return ret;
}


int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
	my_memmove(arr + 2, arr, 4 * sizeof(arr[0]));
	return 0;
}

1.memset 函数

(1)作用：用于修改一定数量字节内容

(2)函数原型：void* my_memset(void* str, char ch, size_t count)

注意事项：一定是以字节为单位的内容修改，将每个字节的内容都进行修改

模拟实现：

void* my_memset(void* str, char ch, size_t count)      //void*str修改字节的起始位置
 													   //char ch 修改成的内容
 													   //size_t  修改的字节数
{
	while (count--)
	{
		*(char*)str = ch;
		++(char*)str;
	}
}

int main()
{
	char ch[20] = { 0 };
	my_memset(ch, '*', 10);
	printf("%s", ch);
	return 0;
}