函数

• 一.字符串函数(使用都需要包含string.h)
• • 1.求字符串长度—strlen
  • 2.长度不受限制的字符串函数
  • • 1.strcpy-字符串拷贝
    • 2.strcat-追加字符串
    • 3.strcmp-字符串比较
    • 4.为什么长度不受限制
  • 3.长度受限制的字符串函数—strncopy,strncat,strncmp
  • 4.字符串查找
  • • 1.strstr-判断是否为子字符串
    • 2.strtok-一个奇怪的函数
  • 5.错误信息查找-strerror
• 二.内存函数（也需要包含string.h）
• • 1.内存拷贝函数—memmove
  • 2.内存填充函数-memset
  • 3.内存比较函数-memcmp

一.字符串函数(使用都需要包含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里的1，2，3，4，5拷贝到3，4，5，6，7上就，理论上arr1[]应该变为1，2，1，2，3，4，5，8，9。

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

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

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

所以接下来分情况讨论。

符合我们的预期。

以下是源码

#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.

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