目录

C语言库函数的模拟实现

1、求字符串长度  ---  strlen的模拟实现

2、拷贝字符串  ---  strcpy的模拟实现

3、追加字符串  ---  strcat的模拟实现

4、比较字符串大小(ASCLL码值) ---  strcmp的模拟实现

5、长度受限制的字符串函数的模拟实现-----strncpy(拷贝字符串 )

6、长度受限制的字符串函数的模拟实现-----strncat(追加字符串  )

7、字符串查找（在一个字符串里查找另一个字符串） --- strstr的模拟实现

8、根据分界符将字符串分割成一个个片段  ---  strtok的模拟实现

9、内存操作函数 ----memcpy的模拟实现

10、内存操作函数 ----memmove的模拟实现

C语言库函数的模拟实现

1、求字符串长度  ---  strlen的模拟实现

size_t strlen ( const char * str );

•  参数指向的字符串必须要以 '\0' 结束。
• 函数的返回值为size_t，是无符号的。

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* arr)//size_t返回值是无符号的
{
	assert(arr);
	const char* start = arr;
	const char* end = arr;
	
	while (*end !='\0')
	{
		end++;
	}
	return end - start;
}
int  main()
{
	char arr[] = "abcdef";
	int len=my_strlen(arr);
	printf("%d", len);
	return 0;
}

2、拷贝字符串  ---  strcpy的模拟实现

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

• 源字符串必须以 '\0' 结束。
• 会将源字符串中的 '\0' 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变。

char* my_strcpy(char* dest, const char* src)
{
	assert(dest);
	assert(src);
	char* ret = dest;
	while ( *dest++=*src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[] = { "abcdef"};
	char arr2[30] = { 0 };

	printf("%s\n", my_strcpy(arr2, arr1));
	return 0;
}

3、追加字符串  ---  strcat的模拟实现

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

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

char* my_strcat(char* dest, const char* src)
{
	//找到目标空间的\0
	char* cur=dest;
	while (*cur != '\0')
	{
		cur++;
	}
	//拷贝数据到源头\0之后的空间
	while (*cur++ = *src++)
		{
				;
		}
	return dest;
}
int main()
{
	char arr1[20] = { "hello " };
	char arr2[] = { "world" };	
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;

}

4、比较字符串大小(ASCLL码值) ---  strcmp的模拟实现

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

标准规定：

• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字

//s1>s1返回一个大于0的数字
//s1 <s1返回一个小于0的数字
//s1=s1返回0
int my_strcmp(const char* s1, const char* s2)
{
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
			return 0;
		s1++;
		s2++;
	}
	return *s1 - *s2;
}
int main()
{
	char arr1[] = { "abcd" };
	char arr2[] = { "abcde" };
	int ret=my_strcmp(arr1,arr2);//比较的是对应位置上的大小，而非长度
	if (ret > 0)
		printf("arr1>arr2");
	if (ret < 0)
		printf("arr1<arr2");
	else
		printf("arr1=arr2");
	return 0;
}

5、长度受限制的字符串函数的模拟实现-----strncpy(拷贝字符串 )

与strcpy的不同之处：strncpy可以指定拷贝的字符数

声明

下面是 strncpy() 函数的声明。

char *strncpy(char *dest, const char *src, size_t n)

参数

• dest -- 指向用于存储复制内容的目标数组。
• src -- 要复制的字符串。
• n -- 要从源中复制的字符数。

返回值

该函数返回最终复制的字符串。

模拟实现代码：

char* my_strncpy(char* dest, const char* src, size_t n)
{
	assert(dest && src);
	while (n-- && *src!='\0')
	{
		*dest++ = *src++;
		
	}
	return dest;
}
int main()
{
	char arr1[] = "hello world";
	char arr2[20]="**********";
	my_strncpy(arr2, arr1, 8);
	printf("%s\n", arr2);
	return 0;
}

6、长度受限制的字符串函数的模拟实现-----strncat(追加字符串  )

 与strcat的不同之处：strncat可以指定追加的最大字符数

声明

下面是 strncat() 函数的声明。

char *strncat(char *dest, const char *src, size_t n)

参数

• dest -- 指向目标数组，该数组包含了一个 C 字符串，且足够容纳追加后的字符串，包括额外的空字符。
• src -- 要追加的字符串。
• n -- 要追加的最大字符数。

返回值

该函数返回一个指向最终的目标字符串 dest 的指针。

模拟实现代码：

char*  my_strncat(char* dest, const char* src, size_t n)
{
	assert(dest && src);
	char* tmp = dest;
	while (*dest!='\0')
	{
		dest++;
	}
	while (n-- && *src!='\0')
	{
		*dest++ = *src++;
	}
	*dest = '\0';
	return tmp;
}
int main()
{
	char arr1[] = "world hhhh";
	char arr2[20] = "hello ";
	my_strncat(arr2, arr1, 5);
	printf("%s\n", arr2);
	return 0;
}

7、字符串查找（在一个字符串里查找另一个字符串） --- strstr的模拟实现

char *strstr(const char *str1, const char *str2)

• str1-- 要被检索的 C 字符串。
• str2 -- 在 str1 字符串内要搜索的小字符串。

该函数返回在 str2中第一次出现 str1字符串的位置，如果未找到则返回 null。

char* my_strstr(const char*str1, const char* str2)
{
	const char* s1 = str1;
	const char* s2 = str2;
	const char* p = str1;
	if (str2 == '\0')
		return str1;
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while (*s1!='\0' && *s2!='\0' && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)p;
		}
		p++;
	}
	return NULL;
}
int main()
{
	char arr1[] = { "abbccd" };
	char arr2[] = { "bcd" };
	char* ret=my_strstr(arr1,arr2);
	if (ret == NULL)
		printf("不存在\n");
	else
		printf("%s\n",ret);
	return 0;
}

8、根据分界符将字符串分割成一个个片段  ---  strtok的模拟实现

char * strtok ( char * str, const char * sep );

• sep参数是个字符串，定义了用作分隔符的字符集合
• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标 记。
• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。）
• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串 中的位置。
• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。
• 如果字符串中不存在更多的标记，则返回 NULL 指针。

#include <stdio.h>
int main()
{
   char *p = "hello@world.com";
 const char* sep = ".@";
 char arr[30];
 char *str = NULL;
 strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
 for(str=strtok(arr, sep); str != NULL; str=strtok(NULL, sep))
 {
 printf("%s\n", str);
 }
}

9、内存操作函数 ----memcpy的模拟实现

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

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

void* my_memcpy(void* dest, const void* src, size_t num)
//num的单位是字节(以字节为单位拷贝)
{
	assert(dest && src);
	void* ret = dest;
	
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2,arr1,8);
	
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	
	return 0;
}

10、内存操作函数 ----memmove的模拟实现

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

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

void* my_memmove(void* dest,const void* src,size_t num)//num的单位是字节
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)//从前向后拷贝
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else//从后向前拷贝
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memmove(arr1+2, arr1, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	
	return 0;
}

10、 atoi ------------把字符串转换为一个整数（类型为 int 型）

int atoi(const char *str)

参数

• str -- 要转换为整数的字符串。

返回值

该函数返回转换后的长整数，如果没有执行有效的转换，则返回零。

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
#include<ctype.h>
// my_atoi(NULL)
// my_atoi("")
// my_atoi("123")
// my_atoi("-123")
// my_atoi("     123")
// my_atoi("111111111111111111111")越界


//需要全局变量来判断返回的值是否合法
enum Status
{
	VALID,
	INVALID
};
enum Status status = INVALID;
int my_atoi(const char* str)
{
	if (str == NULL)
	{
		return 0;
	}
	if (*str == '\0')
	{
		return 0;
	}
	//空白字符
	while (isspace(*str))//isspace()判断字符是否为空白字符
	{
		str++;
	}
	int flag = 1;
	if (*str == '+')
	{
		flag = 1;
		str++;
	}
	else if (*str == '-')
	{
		flag = -1;
		str++;
	}
	//处理数字字符
	long long ret = 0;
	while (isdigit(*str))//isdigit()判断字符是否为数字字符
	{
		ret = ret * 10 + flag*(*str - '0');
		if (ret<INT_MIN || ret>INT_MAX)
		{
			return 0;
		}
		str++;
	}
	if (*str == '\0')
	{
		status = VALID;
		return (int)ret;
	}
	else
	{
		return (int)ret;
	}
}

int main()
{
	int ret = my_atoi("123qqq");
	if(status==VALID)
		printf("合法的转换：%d\n", ret);
	else
		printf("不合法的转换：%d\n", ret);
	return 0;
}