模拟实现字符串库函数及字符串函数注意事项

1.实现strlen.(求字符串长度)

size_t strlen ( const char * str );

• 字符串已经'\0' 作为结束标志，strlen函数返回的是在字符串中'\0' 前面出现的字符个数（不包
• 含'\0' )。
• 参数指向的字符串必须要以'\0' 结束。
• 注意函数的返回值为size_t，是无符号的（ 易错)。

模拟实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
//计数器方式
int my_strlen1(const char * str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
//不能创建临时变量计数器
int my_strlen2(const char * str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen2(str + 1);
}
//指针-指针的方式
int my_strlen3(char *s)
{
	char *p = s;
	while (*p != '\0')
		p++;
	return p - s;
}
int main()
{
	char str[] = "abcdef";
	printf("长度为:%d\n", my_strlen1(str));
	printf("长度为:%d\n", my_strlen2(str));
	printf("长度为:%d\n", my_strlen3(str));
	system("pause");
	return 0;
}

 

2.实现strcpy(字符串拷贝)

char* strcpy(char * dest, const char * src );

• 将src指向的C字符串复制到dest指向的数组中，包括终止空字符（并在该点停止）
• 源字符串必须以'\0' 结束。
• 会将源字符串中的'\0' 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变。

模拟实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//将src指向的C字符串复制到dest指向的数组中，包括终止空字符（并在该点停止）。
char *my_strcpy1(char *dest, const char*src)
{
	char* ret = dest;
	assert((dest != NULL) && (src != NULL));
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
char *my_strcpy2(char *dest, const char*src)
{
	char* ret = dest;
	assert((dest != NULL) && (src != NULL));
	while (*src != '\0')
	{
		*dest++ = *src++;
	}
		*dest = '\0';//注意拷贝条件,否则会死循环.因此应该手动赋值.
		return ret;
}
int main()
{
	char arr2[20] = "0";
	char arr1[] = "hello";
	char *tem1 = my_strcpy1(arr2, arr1);
	char *tem2 = my_strcpy2(arr2, arr1);
	printf("%s\n", tem1);
	printf("%s\n", tem2);
	system("pause");
	return 0;
}

3.实现strcat(字符串连接函数)

char * strcat ( char * destination, const char * source );

 

• 将源字符串的副本附加到目标字符串。中的终止空字符目标由源的第一个字符覆盖，并且在末尾包含一个空字符,两个字符串在destination中连接形成的新字符串。

• 源字符串必须以'\0' 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。

模拟实现:

 #define _CRT_SECURE_NO_WARNINGS 1
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 char *my_strcat(char *dest, const char*src)
 {
 	char*ret = dest;
 	assert((dest != NULL) && (src != NULL));
 	while (*dest!='\0')
 	{
 		dest++;
 	}
 	while (*dest++ = *src++)
 	{
 		;
 	}
 //	//或者上面while循环可用下面注释中代码替换
 // 	while (*src)
 // 	{
 // 		*dest = *src;
 // 		src++;
 // 		dest++;
 // 	}
 // 	*dest = '\0';//注意手动赋值,避免死循环.
 	return ret;
 }
 int main()
 {
 	char arr1[] = "hello";
 	char arr2[] = "~biubiu";
 	char*tem1=my_strcat(arr1, arr2);
 	printf("%s\n", arr1);
 	system("pause");
 	return 0;
 }

4.实现strstr(判断是否为子串)

char * strstr ( const char *, const char * );

• str1 代表主串  str2代表子串.
• strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。

模拟实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
char*my_strstr(const char *str1, const char* str2)
{
	char *ret1 = (char *)str1;
	char *ret2 = (char *)str2;
	char *sout = NULL;
	assert(str1 != NULL && str2 != NULL);
	if (*str2 == '\0')
	{
		return NULL;
	}
	while (*ret1)
	{
		sout = ret1;
		ret2 = str2;
		while (*sout && *ret2 && (*sout == *ret2))
		{
			sout++;
			ret2++;
		}
		if (*ret2 == '\0')
			return ret1;
		ret1++;
	}
}

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "cd";
	printf("%s\n", my_strstr(arr1, arr2));
	printf("%s\n", strstr(arr1, arr2));
	system("pause");
	return 0;
}

5.实现strchr(查找字符出现位置)

const char * strchr（const char * str，int character）;

• 返回str中第一个出现character字符的位置,如果有返回地址,没有返回NULL.
• strstr是在字符串中寻找字符串，而strchr是在字符串中寻找某一个字符

 

模拟实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
char *my_strchr(const char *sorc, char dest)
{
	char *m = NULL;
	while (*sorc != NULL)
	{
		if (*sorc == dest)
		{
			return (char *)sorc;
		}
		*sorc++;
	}
	return NULL;
}

int main()

{
	char *a = "abcdefgh";
	char  b = 'e';
	char *c = my_strchr(a, b);
	printf("%s\n", c);
	system("pause");
}

6.实现strcmp(字符串比较)

int strcmp ( const char * str1, const char * str2 );

• 此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续使用以下对，直到字符不同或直到达到终止空字符。
• 标准规定: 1>第一个字符串大于第二个字符串，则返回大于0的数字 2>第一个字符串等于第二个字符串，则返回0                3>第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int my_strcmp(const char* arr1,const char* arr2)
{
	assert(arr1 != NULL && arr2 != NULL);
	while (*arr1 == *arr2)
	{
		if (*arr1 =='\0')
		{
			return 0;
		}
		arr1++;
		arr2++;
	}
	if(*arr1 > *arr2)
	{
		return 1;
	}
	else
		return -1;
}
int main()
{
	char *arr1 = "abcdef";
	char *arr2 = "abcdg";
	int tem = my_strcmp(arr1, arr2);//1: arr1大 返回1    2: arr2大 返回-1  3: 相等  返回0
	printf("%d\n", tem);
	if (tem==1)
	{
		printf("arr1>arr2");
	}
	else if (tem==-1)
	{
		printf("arr1<arr2");
	}
	else if (tem==0)
	{
		printf("arr1=arr2");
	}
	system("pause");
	return 0;
}

7.实现memcpy(复制值,位置不能重复)

void * memcpy ( void * destination, const void * source, size_t num );

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到'\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。

模拟实现:

 #define _CRT_SECURE_NO_WARNINGS 1
 #include<stdio.h>
 #include<stdlib.h>
 #include<assert.h>
 void* my_memcmp(const void * ptr1, const void * ptr2, size_t num)
 {
 	char* ret = ptr1;
 	assert(ptr1 != NULL && ptr2 != NULL);
 	while (num--)
 	{
 		*(char*)ptr1 = *(char*)ptr2;
		((char*)ptr1)++;//ptr1 = (char *)ptr1 + 1;	
		((char*)ptr2)++;//ptr2 = (char *)ptr2 + 1;
 	}
 	return ret;
 }
 int main()
 {
 	char arr1[30] = "hello";
 	char arr2[10] = "goodboy";
 	char* tem=my_memcmp(arr1+1, arr2, 2);
 	printf("%s\n", tem);
 	system("pause");
 	return 0;
 }

8.实现memmove(复制值,允许位置重复)

void * memmove ( void * destination, const void * source, size_t num );

• 将num字节的值从源指向的位置复制到目标指向的内存块。复制就像使用中间缓冲区一样发生，允许目标和源重叠。
• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

模拟实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <stdlib.h>
void * my_memmove(void * dest, const void * src, size_t num)
{
	char *ret = dest;
	//正常情况下 从前往后逐个拷贝
	if (dest<=src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			((char*)dest)++;
			((char*)src)++;
		}
		return  ret;
	}
	//当出现内存覆盖时 从后向前拷贝
	else
	{
		while (num--)
		{
			*((char*)dest+num) = *((char*)src );
			((char*)dest)++;
			((char*)src)++;
		}
	}

}
int main()
{
	char arr[10] = "abcdefg";
	char arr0[10] = "abcdefg";
	char arr1[10] = { 0 };
	my_memmove(arr + 2, arr, 4);
	printf("内存覆盖情况：%s\n", arr + 2);
	my_memmove(arr1, arr0, 4);
	printf("正常情况：%s\n", arr1);
	system("pause");
	return 0;
}