一.字符串函数

1.strlen——求字符串长度

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

a.strcpy——字符串拷贝

b.strcat——追加字符串

c.strcmp——字符串比较

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

4.字符串查找

a.strstr——判断是否为子字符串

b.strtok——一个奇怪的函数

c.strerror——错误信息查找

二.内存函数

1.内存拷贝函数

a.memmove

b.memcpy

2.内存填充函数——memset

3.内存比较函数——memcmp

博客主页：张栩睿的博客主页

欢迎关注：点赞+收藏+留言

系列专栏：c语言学习

家人们写博客真的很花时间的，你们的点赞和关注对我真的很重要，希望各位路过的朋友们能多多点赞并关注我，我会随时互关的，欢迎你们的私信提问，也期待你们的转发！

希望大家关注我，你们将会看到更多精彩的内容！！！

前言：

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数。

以下的函数都需要引用头文件<string.h>

一.字符串函数

1.strlen——求字符串长度

strlen

函数原型：

函数作用：

字符串以'\0'作为结束标志，strlen函数返回值是在字符串中'\0'前面出现的字符个数（不包含'\0'）
参数是一个字符指针变量
参数指向的字符串必须要以'\0'结束，否则计算出的长度是随机值
注意函数的返回值为size_t，是无符号的

函数注意事项：

因为返回值是size_t，所以就要避免出现下图这样的代码：strlen（“abc”）算出的结果是3， strlen("abcde")算出的结果是5，可能想着3-5得到-2，实际上并不是这样的，这里算出的3和5都是无符号整型，算出的-2也是一个无符号整型，-2在内存中以补码的形式存储，从无符号整型的视角看去，这串补码就表示一个很大的正数。

3种模拟的方法：

递归：

递归
int my_strlen1(const char* str)
{
	assert(str != NULL);
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}

指针-指针

指针-指针
int my_strlen2(const char* str)
{
	const char* start = str;
	assert(str != NULL);
	while (*str)
	{
		str++;
	}
	return str - start;

递推

int my_strlen(const char* str)
{
	assert(str != NULL);
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

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

a.strcpy——字符串拷贝

strcpy

函数原型:

函数作用：

字符串拷贝函数，把源字符串拷贝到目标空间

注意事项：

函数有两个参数，source指向待拷贝的字符串，也叫做源字符串。destination是目标空间的地址
源字符串必须以’\0’结束

目标空间必须足够大，以确保能存放源字符串，否则会出现非法访问

特殊情况：
会把源字符串中的 ‘\0’ 也拷贝到目标空间

目标空间必须可变，例如把源字符串拷贝到一个字符串常量里面是不可取的

模拟实现：

char* my_strcpy(char* destination, const char* source)
{
	assert(destination && source);
	char* ret = destination;
	while (*destination++ = *source++)
	{
		;
	}
	return ret;
}

b.strcat——追加字符串

strcat

函数原型：

函数作用：

字符串追加函数，将源字符串追加到目标字符串后面，目标中的终止字符’\0’会被源字符串的第一个字符覆盖

注意事项：

函数有两个参数，其中source指向要追加的字符串，也叫做源字符串，destination是目标空间的地址
目标空间中必须要有'\0'，作为追加的起始地址
源字符串中也必须要有'\0'作为追加的结束标志
目标空间必须足够大，能容纳下源字符串的内容
目标空间必须可修改

以上与strcpy类似，但是有一点很特殊：
自己给自己追加会陷入死循环！

同学们先看看模拟实现的代码可以知道，该函数本质是将\0覆盖了，再最后追加\0，但是自己改自己会把\0覆盖不见，最后造成死循环。

模拟实现：

char* my_strcat(char* destination, const char* source)
{
	assert(destination && source);
	char* ret = destination;
	while (*destination)
	{
		ret++;
	}
	while (*destination++ = *source++)
	{
		;
	}
	return ret;
}

c.strcmp——字符串比较

strcmp

函数原型：

函数作用：

根据相同位置的ASCII值进行大小的比较。并不是比字符串长度

注意事项：

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

第一个字符串等于第二个字符串，则返回0

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

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

模拟实现：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)//如果相等就进去，两个指针加加，但是可能会出现两个字符串相等的情况，两个指针都指向'\0'，此时比较就结束了
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	if (*str1 > *str2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}

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

为什么会出现这些函数呢？

前面三个函数压根不关心到底拷贝，追加，比较了几个字符。它们只关心是否找到了\0，一旦找到了\0就会停止。这样的话如果目标空间不够大，会造成越界。这些特点就会让人们决定它是不安全的，并且我们之前发现如果自己给自己追加会出现死循环的现象，因为这些缺点，下面介绍较安全的函数。

strncpy函数：

strncpy

函数原型：

函数作用：

长度受限的字符串拷贝

注意事项：

拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

模拟实现：

char* my_strncpy(char* dest, const char* src, int num)
{
	assert(dest && src);
	char* ret = dest;
	while (num)
	{
		if (*src == '\0')//此时说明src指针已经指向了待拷贝字符串的结束标志'\0'处，src指针就不用再++了
		{
			*dest = '\0';
			dest++;
		}
		else
		{
			*dest = *src;
			dest++;
			src++;
		}
		num--;
	}
	return ret;
}

strncat函数

strncat

函数原型：

注意事项：

从源字符串的第一个字符开始往后数num个字符追加到目标空间的后面，外加一个终止字符。
如果源字符串的长度小于 num，则仅复制终止字符之前的内容。

模拟实现：

char* my_strncat(char* dest, const char* src, int sz)
{
	assert(dest && src);
	char* ret = dest;
	//找目标空间的\0
	while (*dest != '\0')
	{
		dest++;
	}
	//追加
	while (sz)
	{
		*dest++ = *src++;
		sz--;
	}
	*dest = '\0';
	return ret;
}

strncmp函数：

strncmp

函数原型：

模拟实现：

int my_strncmp(const char* str1, const char* str2, int sz)
{
	assert(str1 && str2);
	while (sz)
	{
		if (*str1 < *str2)
		{
			return -1;
		}
		else if (*str1 > *str2)
		{
			return 1;
		}
		else if(*str1 == '\0'||*str2 =='\0')//当有一个为'\0'，说明比较就可以结束了
		{
			if (*str1 == '\0' && *str2 == '\0')//如果二者都是'\0'，说明两个字符串相等
			{
				return 0;
			}
			else if(*str1 =='\0')//如果str1为'\0'，说明str1小，str2大
			{
				return -1;
			}
			else//如果src为'\0'，说明str1大，str2小
			{
				return 1;
			}
		}
		sz--;
		str1++;
		str2++;
	}
}

4.字符串查找

a.strstr——判断是否为子字符串

strstr

函数原型：

函数作用：

判断是否为子字符串

注意事项：

在str1指向的字符串中查找str2指向的字符串
返回一个指向str1中第一次出现的str2的指针
如果 str2 不是 str1 的一部分，则返回一个空指针NULL
匹配过程不包括终止空字符，但它到此为止

BF算法(暴力枚举)模拟函数实现：

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	if (*str2 == '\0')
	{
		return (char*)str1;
	}
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* cp = str1;

	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 !='\0' && *s2!='\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)cp;
		}
		cp++;
	}

	return NULL;
}

KMP算法模拟实现：

void Getnext(char* next, char* str2)
{
	next[0] = -1;
	next[1] = 0;
	int k = 0;
	int i = 2;
	while (i <= strlen(str2))
	{
		if (str2[k] == str2[i-1])
			next[i] = k + 1;
		else if (str2[i] != str2[0])
			next[k] = 0;
		else if (str2[i] == str2[0])
			next[k] = 1;
		k++;
		i++;
	}
}
char* KMP(const char* str1, const char* str2)
{
	assert(str1 && str2);
	int* next = (int*)malloc(sizeof(int) * strlen(str2));
	assert(next);
	Getnext(next, str2);
	int i = 0;
	int j = 0;
	while (i < strlen(str1) && j < strlen(str2))
	{
		if (j==-1||str1[i] == str2[j])
		{
			i++;
			j++;
		}
		else
		{
			j = next[j];
		}
	}
	free(next);
	if (i == strlen(str2))
		return &str1[i - j];
	return NULL;
}

关于KMP算法可以通过这两篇博客来了解：

一篇文章弄懂KMP算法

关于next数组

b.strtok——一个奇怪的函数

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。我现在想把这三部分分开。

当然，我们可以用for循环简写：

该函数模拟较复杂，我们就先不模拟了。

c.strerror——错误信息查找

strerror

函数原型：

作用：

把错误码转换成错误信息

注意事项：

C语言的库函数在运行的时候，如果发生错误，就会把错误码存在一个变量中，这个变量是：errno
返回的指针指向静态分配的字符串（错误信息字符串）

一些栗子：

用法：

int main()
{
	//打开文件
	FILE* pf = fopen("test.c", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));//需要包含头文件#include<errno.h>
		return 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	return 0;
}
//打开失败时屏幕显示：
No such file or directory

关于这里的errno，C语言的库函数在运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量是：errno，错误码是一些数字：1 2 3 4 5，我们需要讲错误码翻译成错误消息。

perror函数：

perror

实际上就是printf和strerror的结合！

上面是字符串相关的函数，下面是一些字符分类的函数：

字符转换函数：

tolower：将大写字母转换为小写字母
int tolower ( int c );
toupper：将小写字母转换成大写字母
int toupper ( int c );

这些函数我就不一一讲解了，家人们有兴趣的话可以去官网了解一下哦！

二.内存函数

上面我们介绍了处理字符串的函数，但是对于其他类型，我们该如何处理呢？通过下面的内存函数的介绍，相信你会有所感悟！

1.内存拷贝函数

a.memcpy

函数原型：

注意事项：
这里的destination指向要在其中赋值内容的目标数组，source指向要复制的数据源，num是要复制的字节数，注意这里前两个指针的的类型还有函数返回值都是void*，这是因为，memcpy这个函数是内存拷贝函数，它有可能拷贝整型，浮点型，结构体等等各种类型的数据……虽然返回类型是void*，但他也是必不可少的，void*也表示一个地址，用户可以把它强制转换成自己需要的类型去使用。

函数的模拟实现：

void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	//前->后
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

注意：这里对于(char*)dest不能++或--，因为虽然强制转化类型，但是他的类型实质是没有改变的。

然而，这个函数存在缺陷，就是当对于自己拷贝并且有重叠部分时，会出现bug

如果我们只在一个字符串里操作就会出现问题。例如我想把arr1里的1，2，3，4，5拷贝到3，4，5，6，7上就，理论上arr1[]应该变为1，2，1，2，3，4，5，8，9。

但是实际上：

为了修改这个bug，大佬们又写出了memmove函数！

b.memmove

函数原型和memcpy一样，作用也是一样的，不同的就是可以拷贝自己，并且重叠不会出bug！

为什么之前的模拟实现会出现这个bug呢？

原因是：当1拷贝到3上时，原来的3已经被1替换，当2拷贝到4上的时候，原来的4已将被2替换。所以当拷贝arr[2]到arr[4]上的时候，原本arr[2]里面存放的3已将被1替换了，同理，所以才得出了不符合我们预期的结果。那如何解决这个问题呢？先来分析这个问题产生的原因，这是因为源空间与目标空间之间有重叠，这里的arr[2]、arr[3]、arr[4]既是源空间也是目标空间，当拷贝1和2的时候把源空间中开没有拷贝的3和4就给覆盖了，此时源空间arr[2]和arr[3]里面存的就不再是3和4了，而是1和2，所以此时拷贝arr[2]和arr[3]里面的数据，其实拷贝的就是1和2。为了解决这个问题，我们可以从后往前拷贝，此时就不会出现这样的问题

但是，我们从后往前拷贝就可以解决这个问题吗？答案是当然不是，比如：

所以我们需要分类讨论：

模拟实现：

void* my_memmove(void* dest, const void*src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	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;
}

2.内存填充函数——memset

函数作用：

内存设置

注意事项：

以字节为单位来设置内存中的数据，把从ptr开始往后的num个字节设置成value
形参value也可以是字符，字符其实也是整型，因为字符在内存中存的是其ASCII
value如果是整数的话，需要注意它的取值范围，因为一个字节最大可以存储255，超过255就会发生截断
由于这个函数是一个字节一个字节的改变，所以有些初始化是不成立的，比如对于整形数组初始化为1是不可能实现的，因为每个字节都变成01，一个整形事实上是一个很大的数字。所以对于整形数组初始化，一般都是初始化为0或-1.当然对于字符，不必担心，他本身也是一个字符一个字符改变的！