模拟实现C语言中常用函数

文章目录

• 模拟实现C语言中常用函数
• • 1、strlen
  • 2、strcpy
  • 3、strcat
  • 4、strcmp
  • 5、strncpy、 strncat、 strncat
  • 6、strstr
  • • 1、strstr原理介绍
    • 2、strstr应用举例
  • 7、strtok
  • • 1、strtok原理介绍
  • 8、strerror
  • 9、 memcpy
  • • 1、memcpy简单介绍
    • 2、模拟实现memcpy
  • 10、memmove
  • • 1、memove简单介绍
    • 2、模拟实现memmove

模拟实现C语言中常用函数 1、strlen

strlen是求字符串长度的函数

size_t strlen ( const char * str );

//1、字符串以 '' 作为结束标志，strlen函数返回的
//   是在字符串中 '' 前面出现的字符个数（不包含 '' )。

//2、参数指向的字符串必须要以 '' 结束。
//3、注意函数的返回值为size_t，是无符号的

看到这里，我相信大家有一个疑问，那就是 str1的长度是6，str2的长度是3，所以str2的长度减str1的长度是小于0的，可是结果却是str2>str1；
那么这个时候 strlen的返回值为size_t，是无符号的这句话就特别重要了。看图片详细解释

因此，strlen(str2)-strlen(str1) 返回的值是4294967293，并不是-3；

//模拟实现strlen 
    #include
    int count = 0;
	int test(char* ptr)
	{

		if (*ptr == 0)//递归结束条件
		{
			return 0;
		}

		return test(ptr + 1) + 1;
    //用递归法来实现

	}
	int main()
	{
		char arr[] = "abcdef";
		int len=test(arr);
		printf("%dn", len);
		return 0;
	}

2、strcpy

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

//1、源字符串必须以 '' 结束。
//2、会将源字符串中的 '' 拷贝到目标空间。
//3、目标空间必须足够大，以确保能存放源字符串。
//4、目标空间必须可变。

strcpy是拷贝字符串的函数

char* destination：是目标空间的地址
char* source：是原字符串首元素的地址

//模拟实现strcpy

#include
char* my_strcpy(char* str, const char* ptr)
{
	char* str1 = str;
	while (*str++ = *ptr++)
		//因为*的优先级大于后置++
		//所以*str++ = *ptr++可以看成下面这样
		//{
		//	*str = *ptr;
		//	str++;
		//	ptr++;
		//}
    {
		;
	}
	return str1;
}
int main()
{
	char arr[20] = { 0 };
	char name[] = "nishishei";
	//将name数组中的内容拷贝到arr数组中
	my_strcpy(arr, name);

	printf("%sn", arr);
	return 0;
}

3、strcat

strcat是字符串追加函数

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

//1、源字符串必须以 '' 结束。
//2、目标空间必须有足够的大，能容纳下源字符串的内容。
//3、目标空间必须可修改。

    #include
	char* my_strcat(char* str, char* ptr)
	{
		char* btr = str;
		while (*str != 0)
		//通过while循环找到字符串结束的位置
		{
			str++;
		}
		while (*str++ = *ptr++)
		//将我们想要追加的字符串拷贝进目标字符串
		{
			;
		}
		return btr;
	}
	int main()
	{
		char arr[] = "ni shi ";
		//初始化数组arr
		my_strcat(arr, "shei");
		//将 shei 追加给数组arr
		printf("%sn",arr);
		return 0;
	}

4、strcmp

strcmp是比较字符串大小的函数
注意。他比较的并不是字符串长度的大小，而是一个字节一个字节的比较，比较的是字符的ASCII值

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

//1、第一个字符串大于第二个字符串，则返回大于0的数字
//2、第一个字符串等于第二个字符串，则返回0
//3、第一个字符串小于第二个字符串，则返回小于0的数字

#include
#include
int my_strcmp(char* str, char* ptr)
{
	assert(str && ptr);
	//为了安全，防止出现空指针
	while (*str == *ptr)
	//如果字符相等，进入循环，比较下一个字符
	{
		if (*str == '')
		//如果两个字符串相等且有一方为'0'
		//说明这两个字符串相等，返回0；
		{
			return 0;
		}
		str++;
		ptr++;
	}
	return (*str - *ptr);
}
int main()
{
	char arr[] = "abcc";
	char name[] = "abca";
	int ret = my_strcmp(arr, name);
	if (ret < 0)
		printf(" 0)
		printf(">n");
	else
		printf("==n");
}

5、strncpy、 strncat、 strncat

这三个函数与上面说的第2、3、4个函数并无本质区别，只是设定了特定的字符个数来执行、

char* strncpy (char * destination, 
            const char * source, size_t num );
//1、拷贝num个字符从源字符串到目标空间。
//2、如果源字符串的长度小于num，则拷贝完源字符串
//   之后，在目标的后边追加0，直到num个。

char* strncat (char* destination, 
           const char * source, size_t num );

#include 
#include 
int main ()
{
 char str1[20];
 char str2[20];
 strcpy (str1,"To be ");
 strcpy (str2,"or not to be");
 strncat (str1, str2, 6);
 puts (str1);
 return 0;
}

6、strstr 1、strstr原理介绍

strstr是查找字符串函数

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

查找字符串函数是将原有的字符串的首元素地址付赋一个指针变量，然后通过指针变量来查找我们要查找的目标字符串，如果找到，那么将指针变量返回，否则返回空指针。

模拟实现strstr

#include
#include
char* my_strstr(char* str, char* ptr)
{
	assert(str && ptr);
	char* s1 = str;
	char* s2 = ptr;
	char* p = str;
	while (*p)
	{
		s1 = p;
		s2 = ptr;
		while (*s1 != '' && *s2 != '' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (* s2 == '')
		{
			return p;
		}
		p++;
	}
	return NULL;
}
int main()
{
	char arr[] = "abbcdef";
	char arr1[] = "bbc";
	char* ret = my_strstr(arr, arr1);
	printf("%sn", ret);
	return 0;
}

举个例子

2、strstr应用举例

7、strtok

strtok是字符串切割函数

1、strtok原理介绍

char * strtok ( char * str, 
                const char * sep )
//1、sep参数是个字符串，定义了用作分隔符的字符集合

//2、第一个参数指定一个字符串，它包含了0个或者多个
//由sep字符串中一个或者多个分隔符分割的标记。

//3、strtok函数找到str中的下一个标记，并将其用
//  结尾，返回一个指向这个标记的指针。
//（注：strtok函数会改变被操作的字符串，所以在使用
//strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

//4、strtok函数的第一个参数不为 NULL ，函数将
//找到str中第一个标记，strtok函数将保存它在字符串中的位置。

//5、strtok函数的第一个参数为 NULL ，函数将
//在同一个字符串中被保存的位置开始，查找下一个标记。

//6、如果字符串中不存在更多的标记，则返回 NULL 指针。

#include 
#include 
int main()
{
	//char str[] = "- This, a sample string.";
	char str[] = " ni shi shei,  nihao.";

	char* pch;
	printf("Splitting string "%s" into tokens:n", str);
	pch = strtok(str, " ,.-");
	while (pch != NULL)
	{
		printf("%sn", pch);
		//第一次pch返回的是T的地址
		// 
		//第二次返回的是a的地址，因为我们没有找到
		//下一个分隔符但是遇到了空格，所以pch指向了下一个单词

		//第三次返回s
		//第四次返回s

		pch = strtok(NULL, " ,.-");
	}
	return 0;
}

8、strerror

strerror是一个返回错误码，所对应的错误信息的函数

char * strerror ( int errnum );

注意：必须包含头文件#include

9、 memcpy 1、memcpy简单介绍

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

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

2、模拟实现memcpy

void* memcpy(void* dst, const void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);
	//防止 dst 与 src是空指针
	while (count--) 
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return(ret);
}

10、memmove 1、memove简单介绍

void* memmove (void* destination, 
            const void* source, size_t num )
            
            
//1、和memcpy的差别就是memmove函数处理的
//源内存块和目标内存块是可以重叠的。
//2、如果源空间和目标空间出现重叠，
//就得使用memmove函数处理。

memove可以实现字符串本身的拷贝

2、模拟实现memmove

void* memmove(void* dst, const void* src, size_t count) 
{
	void* ret = dst;
	if (dst <= src || (char*)dst >= ((char*)src + count)) 
	{
		while (count--) 
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		dst = (char*)dst + count - 1;
		src = (char*)src + count - 1;
		while (count--)
	    {
			*(char*)dst = *(char*)src;
			dst = (char*)dst - 1;
			src = (char*)src - 1;
		}
	}
	return(ret);
}

如果有错误，欢迎批评指正！

暑期编程PK赛 得CSDN机械键盘等精美礼品！