各类字符串函数和内存函数的使用以及模拟（万字解析）

一.字符串函数(使用都需要包含string.h)

1.求字符串长度—strlen

库函数的使用

字符串的结尾标志是\0而strlen统计的就是\0出现之前字符的个数。不包含\0

注意在库里该函数的参数是字符串的起始地址返回类型是size_t也就是无符号整形。在设计者的眼中长度肯定是非负数所以这样设计。但实际这样会有一些使用上细节的差异例如你就不能如下使用。

模拟实现ps:有多种方法这里写最简单的方法

#include<assert.h>
#include<stdio.h>
#include<string.h>
int my_strlen(const char* s)
{
	assert(s);
	int n = 0;
	while (*s != '\0')
	{
		s++;
		n++;
	}
	return n;
}
int main()
{
	char* s = "abcd";
	int p = my_strlen(s);
	printf("%d", p);
}

可以看到我加上了const和assert。其实这两个东西是来保障代码的安全性的当然不加也能运行。但作为一个好的程序员应该经常使用const和assert。const的作用是保证所对应的变量不能被修改。asser是断言在这就是如果s为空指针编译器就会发出警告以方便程序员查找问题。

返回型是int还是size_t没有好坏之分要看使用的场景。

2.长度不受限制的字符串函数

1.strcpy-字符串拷贝

库函数的使用

将后面的拷贝到前面的字符串里。

1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷贝到目标空间。
3.目标空间必须足够大以确保能存放源字符串。
4.目标空间必须可变。

前三点很好理解拷贝首先得需要知道要拷贝的长度啊那就必须得有\0。然后拷贝字符时会将\0一起拷过去。

第四点空间必须可被改变的意思是不能为常量字符串。

模拟实现

char* my_strcpy(char* s1, const char* s2)//要拷贝的字符串不可被改变
{
	char* ret = s1;
	assert(s1 && s2);//都不为空指针
	while (*s1++ = *s2++)
	{
		;
	}
	return ret;
}
int main()
{
	char s1[20] = "abcdefg";
	char s2[] = "hello";
	my_strcpy(s1, s2);
	printf("%s", s1);
	return 0;
}

2.strcat-追加字符串

把后面的字符加到前面来。

从源字符串的\0开始追加并且会覆盖掉源字符串的\0。

模拟实现

char* my_strcat(char* s,const char* str)
{
	assert(s && str);
	char* ret = s;
	//找到源字符串\0
	while (*s != '\0')
	{
		s++;
	}
	//追加
	while (*s++ = *str++)
	{
		;
	}
	return ret;
}
int main()
{
	char s[20] = "hello ";//我想在后面追加一个world
	my_strcat(s, "world");
	printf("%s", s);
	return 0;
}

3.strcmp-字符串比较

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

该函数是按字典序来比较的。

在VS上返回大于0的是1小于0的是-1。

模拟实现

int my_strcmp(const char* s1,const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	if (s1 > s2)
		return 1;
	else
		return -1;
}
int main()
{
	char s1[] = "abcd";
	char s2[] = "abc";
	int ret =my_strcmp(s1, s2);
	printf("%d", ret);
	return 0;
}

4.为什么长度不受限制

前面三个函数压根不关心到底拷贝追加比较了几个字符。它们只关心是否找到了\0一旦找到了\0就会停止。这样的话如果目标空间不够大会造成越界。这些特点就会让人们决定它是不安全的下面介绍安全的函数。

3.长度受限制的字符串函数—strncopy,strncat,strncmp

可以看到其实这些函数的原理并没有改变只是多出了一个参数。这个参数就是用来限制它们的长度的。

一个例子

这里只拷贝了三个字符自然没拷贝\0所以字符串结束的\0在s1里。其他函数也是如上使用。

4.字符串查找

1.strstr-判断是否为子字符串

模拟实现

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	if (*str2 == '\0')
	{
		return (char*)str1;//如果传的是空字符串就毫无意义直接返回,str1类型是const char*,这里强转一下避免警告
	}
	const char* s1 = str1;//s1代表str1正在匹配的位置
	const char* s2 = str2;//s2代表str2正在匹配的位置
	const char* cp = str1;//cp代表开始匹配的位置
	while (*cp != '\0')
	{
		s1 = cp;//让str1从cp位置再开始匹配
		s2 = str2;//str2回到初始位置再从第一个元素开始匹配
		while ((*s1!='\0')&&(*s2!='\0') &&(* s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)cp;//查找成功,cp类型是const char*,这里强转一下避免警告
		}
		if (*s1 == '\0')
		{
			break;
		}
		cp++;//像后移一位避免重复元素影响判断
	}
	return NULL;//没有找到
}
int main()
{
	char s1[] = "abbbbbcdef";
	char s2[] = "bbcdq";
	char* ret = my_strstr(s1, s2);//判断s2是否为s1的子字符串
	if (ret == NULL)//如果是则返回s2在s1里第一次出现时的地址否则就返回空指针
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

2.strtok-一个奇怪的函数

1.sep参数是个字符串定义了用作分隔符的字符集合第一个参数指定一个字符串它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

2.strtok函数找到str中的下一个标记并将其用 \0 结尾返回一个指向这个标记的指针。注strtok函数会改变被操作的字符串所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。
3. strtok函数的第一个参数不为 NULL 函数将找到str中第一个标记strtok函数将保存它在字符串中的位置。
4.strtok函数的第一个参数为 NULL 函数将在同一个字符串中被保存的位置开始查找下一个标记。
5.如果字符串中不存在更多的标记则返回 NULL 指针。

用来分割字符串。一个例子例如我的邮箱是xxxxx@163.com。这个邮箱起始由三部分组成一个是xxxxxx一个是163一个是com。我现在想把这三部分分开。

以下可以简写

5.错误信息查找-strerror

具体使用稍微有些超纲只是用来展示使用方法

此时我们只看到打开文件失败但是不知道具体原因所以需要使用该函数。

因为我的路径下没有这个文件所以就是找不到。

另一个相对应的函数-perror

这个函数很简单就是printf+strerrror的结合。

二.内存函数也需要包含string.h

1.内存拷贝函数—memmove

前面介绍过strcpy将一个字符串的内容拷贝到另一个字符串里但它只能作用于字符串。但memmove能够作用于任意类型它的拷贝单位是字节。

该函数也是将后面的拷贝进前面的第三个参数是拷贝的字节多少。

模拟实现

其实这样写是不严谨的如果我们只在一个字符串里操作就会出现问题。例如我想把arr1里的12345拷贝到34567上就理论上arr1[]应该变为121234589。

很明显这是不符合预期的因为前面复制到后面的会直接将后面的覆盖掉所以我们得完善判断方法。

对于这种情况我们考虑从后往前拷贝。

是不是我们所有的直接从后往前拷贝就行了呢当然也不行还有以下这种情况。

所以接下来分情况讨论。

符合我们的预期。

以下是源码

#include<assert.h>
#include<stdio.h>
#include<string.h>
void* my_memmove(void* dest, const void* stc, size_t num)
{
	void* ret = dest;
	assert(dest && stc);
	if (dest < stc)//dest在stc左边从前往后拷贝
	{
		while (num--)
		{
			*(char*)dest = *(char*)stc;
			dest = (char*)dest + 1;
			stc = (char*)stc + 1;
		}
	}
	else//从后往前拷贝
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)stc + num);
		}
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9 };
	my_memmove(arr1+2, arr1, 20);//把一个数组前面的拷贝到后面来

	return 0;
}

追加个知识memcopy在vs上跟memmove没有区别。在其他环境下可能不能实现上面的重复问题。

2.内存填充函数-memset

在dest数组里把count个字节设置成c。

但要注意的是memset是按照字节来改变的也就是说如果我们要改变一个int类型的数组可能就会出现错误。

这里是按16进制显示每两个数表示一个字节。我们可以看到每个字节都变为了01。实际结果并不是我们所期望的1.

3.内存比较函数-memcmp

按字节比较大小如果大于返回大于0的数如果小于返回小于0的数如果等于返回0.

这里也能比较任意类型数据因为是按照字节大小来比较的所有数据都会转化成字节来比较。