前言

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

C语言的库函数分类

• IO函数 prntf、scanf

  字符函数

  字符串函数

  内存函数

  时间日期函数

  数学函数

重点会讲解常用的，本次的内容主要在介绍内存函数和字符串函数

求字符串长度

strlen

• 字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。

  参数指向的字符串必须要以 ‘\0’ 结束。

  注意函数的返回值为size_t，是无符号的（ 易错 ）

  学会strlen函数的模拟实现

char arr[] = "hello Mozart";
size_t len = strlen()

strlen的一些小细节

void functest() 
{
	char arr1[] = "abdc";
	char arr2[] = "abdef";

	if (strlen(arr1) - strlen(arr2) > 0) 
	{
		printf("hehe\n");
	}
	else
	{
		printf("haha\n");
	}
}

会打印hehe，因为返回值类型是size_t，是一个无符号类型的结果，（并不会存在负数），当然强制类型转换就会得到一个有符号类型的结果（存在负数）

void functest() 
{
	char arr1[] = "abdc";
	char arr2[] = "abdde";

	if ((int)strlen(arr1) - (int)strlen(arr2) > 0) 
	{
		printf("hehe\n");
	}
	else
	{
		printf("haha\n");
	}
}

strlen函数的模拟实现

非递归写法

//非递归写法
int my_strlen(char* str)
 {
 	int count = 0;
 	while('\0' != *str)
 	{
 		count++;
 		str++;
 	}
 	return count;
 }

递归写法

//递归写法
nt my_strlen(char *str)
{
	if('\0' == *str)
		return 0;
	else
		return 1+my_strlen(1+str);
}

指针相减法

int my_strlen(char* str)
 {
 	char *dest = str;
	while(*dest++)
 	{
 		;
 	}
 	//除去‘\0’
 	return dest - str - 1;
 }

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

strcpy

使用时注意事项

• 源字符串必须以 ‘\0’ 结束。

  会将源字符串中的 ‘\0’ 拷贝到目标空间。

  目标空间必须足够大，以确保能存放源字符串。

  目标空间必须可变。

  学会模拟实现。

举例1、

void functest() 
{
	char arr1[] = "xxxxxxxxxxxx";
	char arr2[] = "abcd";

	strcpy(arr1,arr2);
	printf("%s ",arr1);
}

会将字符串的结束标记 ’ \0’也给拷贝进去，直到遇到 ’ \0 '，strcpy的工作也就结束了

举例2、

目标空间足够大

依然是使用原来的代码，方便大家理解，在这里可以看到要想将arr2的内容拷贝至arr1，arr1的空间必须足够大，实际上并没有给出一块合适的空间来预存arr2的内容，那么后果也是可想而知

void functest() 
{
	char arr1[] = "xxx";
	char arr2[] = "abcd";

	strcpy(arr1,arr2);//err
	printf("%s ",arr1);
}

举例3、

目标空间必须可变，在学习指针的时候还记得字符指针用来存放字符首地址吗
char *ptr = "hello Mozart"
为了保护字符串习惯于在前面加const
const char *ptr = "hello Mozart"

代码可不能这样写哦，受const保护的字符串是不允许被修改的

void functest() 
{
	const char* ptr1 = "xxxxxxx";
	char* ptr2 = "abc";
	strcpy(ptr1,ptr2);//err
	printf("%s ",ptr1);
}

strcpy模拟实现

char *my_strcpy(char *dest,const char *src) 
{
	assert(dest && src);
	char *tmp = dest;
	while (*tmp ++ = *src++) 
	{
		;
	}
	
	return dest;
}

strcat

又叫字符串链接和字符串追加

• 源字符串必须以 ‘\0’ 结束。

  目标空间必须有足够的大，能容纳下源字符串的内容。

  目标空间必须可修改。

  字符串自己给自己追加，如何？

  使用示范

void func3()
{
	char arr[20] = "abcdef";
	//char arr[] = "abcdef";  err，空间不够
	strcat(arr,"def");
	printf("%s ",arr);
}

int main() 
{
	func3();
	return 0;
}

如果你在使用strcat的时候遇到过这种情况，只需要在程序最开始的位置处加一个宏定义

错误示范

void func3()
{
	char arr1[20] = "abcdef";
	char arr2[20] = {'a','b','c'}; //字符数组末尾没加‘\0’
	strcat(arr1, arr2);
	printf("%s ",arr1);
}

int main() 
{
	func3();
	char arr;
	scanf("%s ",&arr);
	return 0;
}

当想将一个字符数组arr2的内容追加到另外一个字符数组arr1中去，strcat是遇到 ‘\0’ 才会停止追加字符的，而arr2中并未出现
‘\0’，由于在内存中‘\0’的出现时机并不是很明确，可能在‘\0’还未出现之前，追加过去的字符内容就已经足以导致arr1越界了，可能存在越界，但是程序是明显崩了，这一点请务必注意

模拟实现strcat

整体思路就是找到源字符串的末尾位置，存放‘\0’的位置处，从这里开始将待追加字符串全部拷贝过去

char * my_strcat(char *s1, const char * s2)
{
	//防止对空指针解引用
	assert(s1 && s2);
	char *dest = s1;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *s2++)
	{
		;
	}
	// strcat返回的是目标空间的起始地址
	return s1;
}

strcmp

是比较字符串的内容(Ascii码值)，并不是比较长度

• 标准规定：

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

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

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

  那么如何判断两个字符串？

可以通过strcmp的返回值来比较字符串的大小

void func3()
{
	char arr1[] = "abdc";
	char arr2[] = "abdc";
	int ret = strcmp(arr1,arr2);
	if (ret > 0)
		printf(">\n");
	else if (ret == 0)
		printf("==\n");
	else
		printf("<\n");
}

模拟实现strcmp

//模拟实现strcmp
int my_strcmp(const char *s1, const char * s2)
{
   //防止对空指针解引用
	assert(s1 && s2);

	while (*s1 == *s2)
	{
		if (!(*s1))
			return 0;
		++s1;
		++s2;
	}
	return *s1 - *s2;
}

长度受限制的字符串函数介绍

相对于上面的函数使用起来会更安全，但是功能上是一样的

strncpy

• 拷贝num个字符从源字符串到目标空间。

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

void func3()
{
	char arr1[12] = "abdc";
	char arr2[] = "abdc";
	strncpy(arr1,"xxxxxxxxxxx",11);
	printf("%s ",arr1);
}

源字符串的长度刚好等于num

当源字符串的长度刚好小于num，在字符串后面补0

strncat

• 将源的第一个num字符附加到目标，再加上一个结束的空字符。

  如果source中的C字符串长度小于num，则只复制到终止空字符’\0’之前的内容

可以指定追加num个字符

void func3()
{
	char arr1[] = "abcd\0xxxxxxxxxx";
	char arr2[] = "defg";
	strncat(arr1, arr2,3);
	printf("%s ",arr1);
}

可以看出是在目标字符串的‘\0’位置开始追加3个字符，末尾自动补‘\0’

strncmp

• 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完

指定比较两个字符串出现的前num个字符

void func3()
{
	char arr1[] = "abcdxxxxxxxxxx";
	char arr2[] = "abcd";
	//比较字符串的内容
	if(!strncmp(arr1, arr2, 4))
		printf("相等\n");
	else
		printf("不相等\n");

}

字符串查找

strstr

• 返回一个指向str1中第一次出现的str2的指针，如果str2不是str1的一部分，则返回一个空指针。

void func3()
{
	char arr1[] = "abcdxxxxxxxxxx";
	char *ret = strstr(arr1,"abcd");
	if (ret == NULL)
		printf("找不到");
	else
	//找到了就打印该字符串
		printf("%s ", ret);

}

模拟实现

基本思路：备份两个字符串的起始地址，s1表示字符串的首地址，s2表示子串的首地址，
1、s1和s2同时走的情况，*s1 == *s2
2、如果 * s1 ！= * s2，那么cp++，因为前一个字符都已经不相等了，就可以从后面的字符中开始找字串
3、s1找着找着中途不与s2相等了，那么s1回到它的开始处查找(cp的位置)，而s2依然是从它的起始位置开始，s1和s2继续比较

char *my_strstr(const char *str1, const char *str2)
{
	assert(str1 && str2);
	char *cp = str1, *s1 ,*s2;
	while (*cp) 
	{
		//cp记录str1起始位置
		s1 = cp;
		//s2记录sr2的起始位置
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) 
		{
			s1++;
			s2++;
		}
		//找到的情况
		if (*s2 == '\0')
			return cp;
		//如果没有找到cp++
		cp++;
	}
	return NULL;
}

比较的好的情况

不好的情况

strtok

• sep参数是个字符串，定义了用作分隔符的字符集合

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

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

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

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

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

int main()
{
	char arr1[] = "CSDN@IT莫扎特.Mozart";
	char arr2[40] = { 0 };
	// 临时拷贝的内容
	strcpy(arr2,arr1);
	//用作分隔符的字符集合
	char tmp[] = "@.";
	
	for (char *ret = strtok(arr2, tmp); ret != NULL; ret = strtok(NULL, tmp))
	{
	//打印返回的字符串
		printf("%s \n",ret);
	}
}

使用效果还是很明显的

希望我梳理的流程图对你有所帮助

错误信息报告

strerror

解释errnum的值，生成一个带有描述错误条件的消息的字符串，就像被库的函数设置为errno一样。
返回的指针指向一个静态分配的字符串，程序不能修改该字符串。对这个函数的进一步调用可能会覆盖它的内容(不需要特定的库实现来避免数据竞争)。
strerror产生的错误字符串可能是特定于每个系统和库实现的。

c语言会将库函数的错误信息存放到errnum
这个变量当中，每个错误码都会有一条它的具体信息，strerror可以返回c语言错误码对应的信息，

以下举得几个例子就当对这个函数的了解，有兴趣可以自己去研究研究

	printf("%s \n", strerror(0));
	printf("%s \n", strerror(1));
	printf("%s \n", strerror(2));
	printf("%s \n", strerror(3));

int main()
{
	 FILE *pf = fopen("test.txt","r");
	 if(pf == NULL)
	 {
	 	printf("%s \n",strerror(errno));
	 	写成下面这个函数也是可以
	 	//perror("错误信息:\n");
	 }
	 else
	 {
	 	printf("文件打开成功\n");
	 }
	 
	return 0;
}
 

内存操作函数

memcpy

官方文档

• 将num字节的值从source所指向的位置直接复制到destination所指向的内存块。

  源指针和目标指针所指向的对象的底层类型与此函数无关;结果是数据的二进制副本。

  该函数不检查source中是否有任何终止的空字符——它总是精确地复制num字节。

  为了避免溢出，目标和源参数所指向的数组的大小必须至少为num字节，并且不能重叠(对于重叠的内存块，memmove是一种更安全的方法)。

C语言中文网解读

memcpy() 用来复制内存，其原型为：
void * memcpy ( void * dest, const void * src, size_t num );

memcpy() 会复制 src 所指的内存内容的前 num 个字节到 dest 所指的内存地址上。

memcpy() 并不关心被复制的数据类型，只是逐字节地进行复制，这给函数的使用带来了很大的灵活性，可以面向任何数据类型进行复制。

需要注意的是： dest 指针要分配足够的空间，也即大于等于 num 字节的空间。如果没有分配空间，会出现断错误。 dest 和 src
所指的内存空间不能重叠（如果发生了重叠，使用 memmove() 会更加安全）。
稍后再来解决memcpy函数内存重叠的问题

与 strcpy() 不同的是，memcpy() 会完整的复制 num 个字节，不会因为遇到“\0”而结束。

【返回值】返回指向 dest 的指针。注意返回的指针类型是 void，使用时一般要进行强制类型转换。

举例使用

将一个数组中的内容拷贝到另一个数组中去

int arr1[10] = {9,8,7,6,5,4,3,2,1,0};
	int arr2[10] = { 0 };
	memcpy(arr2,arr1,sizeof(int) * 10);
	for (int i = 0; i < 10; i++) 
	{
		printf("%d ",arr2[i]);
	}

模拟实现

思路：
原数组拷贝到目标数组中，拷贝的是数据，而数据又分类型，为了更方便的达到实现的目的，将使用一个字节一个字节地拷贝

一个字节一个字节拷贝

void * my_memcpy(void * dest, const void * src, size_t num)
{
	assert(dest && src);
	void * tmp = dest;
	while (num--) 
	{
		//一个字节拷贝
		*(char *)dest = *(char *)src;
		//dest指向下一个字节
		dest = (char *)dest + 1;
		//src指向下一个字节
		src = (char *)src + 1;
	}
	return tmp;
}
int main()
{
	int arr1[10] = {0,1,2,3,4,5,6,7,8,9};
	int arr2[10] = { 0 };
	my_memcpy(arr2,arr1,sizeof(int) * 10);
	for (int i = 0; i < 10; i++) 
	{
		printf("%d ",arr2[i]);
	}
}

最终的效果

memcpy内存重叠问题继续探讨，memmove的引入

这里会有一个内存被覆盖的问题

	int arr[10] = {0,1,2,3,4,5,6,7,8,9};
	
	my_memcpy(arr + 2,arr,16);
	for (int i = 0; i < 10; i++) 
	{
		printf("%d ",arr[i]);
	}

从起始地址arr每每间隔两个整形(arr + 2)，每次拷贝一字节，循环16次（4 * 4）int * 4，相当于用前两个整形元素覆盖掉后面两个整形元素

执行结果也确是如此要想解决这个问题就得引入memmove

memmove

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

  如果源空间和目标空间出现重叠，就得使用memmove函数处理

使用memmove后，可以看出效果还是很明显的不会发生内存重叠

int main()
{
	int arr[10] = {0,1,2,3,4,5,6,7,8,9};
	
	memmove(arr + 2,arr,16);
	for (int i = 0; i < 10; i++) 
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

memmove的模拟实现

思路：要想实现内存不重叠，将原数据src拷贝到目标数据dest，那么前提是从前往后拷贝呢？还是从后往前拷贝？

从前往后拷贝

思考：可以看出如果是从前往后拷贝，那么3 4就已经被覆盖了，原本的数据也被改成了1 2，再将数据拷贝到5 6的时候那么就是1 2 1 2 1
2 7 8 9 10了，很明显不符合我们想达到的预期结果

从后往前拷贝

思考：那么这种情况就很符合我们的预期结果了

但仅仅是这样思考 还是不够

思考：如果dest和src的位置互换了之后呢？ 即使是从后向前拷贝数据还是被覆盖了

解决方案： dest 在 src的左边，从前往后拷贝

src在dest的左边，从后向前拷贝

重叠的情况，从后向前

dest 在 src的右边，从后往前拷贝，从后往前拷贝都可以

梳理逻辑

实现代码

void *my_memove(void *dest,const void *src,size_t count) 
{
	assert(dest && src);
	void *ret = dest;

	if (dest < src) 
	{
		//从前向后拷贝

		while (count--) 
		{
			*(char *)dest = *(char *)src;
			//指针往后偏移
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}	
	}
	else 
	{
		//从后向前拷贝
		while (count--) //count的大小决定了指针偏移到了哪个位置
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}

	return ret;
}

memset

将ptr指向的内存块的第一个num字节设置为指定的值(解释为unsigned char)。

	int arr[5] = { 1,2,3,4,5 };
	memset(arr,0,20);

memcmp

比较ptr1指向的内存块的第一个num字节和ptr2指向的第一个num字节，如果它们都匹配则返回0，如果不匹配则返回一个不同于0的值，表示哪个值更大。

注意，与strcmp不同，该函数在找到空字符后不会停止比较。

内存比较函数，比较的是内存中的内容

	int arr1[10] = { 0,1,2,3,4,5,6,7,8,9 };// 00 00 00 00 01 00 00 00 02 00 00 00
	int arr2[10] = { 0,1,2,3,4,5,6,7,8,9 };//00 00 00 00 01 00 00 00 02 00 00 00
	if (memcmp(arr1, arr2, 13) == 0)
		printf("相等\n");
	else
		printf("不相等\n");