高阶C语言|字符函数和字符串函数--函数的模拟实现

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

字符函数和字符串函数

  • 一、求字符串长度
    • 1.1strlen的使用
    • 1.2strlen函数的模拟实现
  • 二、长度不受限制的字符串函数
    • 2.1strcpy的使用
      • 2.1.1strcpy函数的模拟实现
    • 2.2strcat的使用
      • 2.2.1strcat函数的模拟实现
    • 2.3strcmp的使用
      • 2.3.1strcmp函数的模拟实现
  • 三、长度受限制的字符串函数介绍
    • 3.1strncpy
    • 3.2strncat
    • 3.3strncmp
  • 四、字符串查找
    • 4.1strstr的使用
      • 4.1.1strstr函数的模拟
    • 4.2strtok
  • 五、错误信息报告
    • 5.1strerror
  • 六、字符操作
  • 七、内存操作函数
    • 7.1memcpy的使用
      • 7.1.1memcpy函数的模拟
      • 7.1.2memcpy的source与destination的重叠
    • 7.2memmove的使用
      • 7.2.1memmove函数的模拟
    • 7.3memcmp

一、求字符串长度

strlen
size_t代表strlen函数返回的是一个无符号整形,str指向的是字符串,接收字符串的地址

  • 字符串已经以’\0’作为结束标志,strlen函数返回的是在字符串中’\0’前面出现的字符个数(不包含’\0’)
  • 参数指向的字符串必须要以’\0’结束
  • 注意函数的返回值为为size_t,是无符号的(易错)

1.1strlen的使用

#include 
#include 
int main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	if ((int)strlen(str2) - (int)strlen(str1) > 0)
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("str1>str2\n");
	}
	return 0;
}

运行结果:
在这里插入图片描述

注意:当用strlen来比较两个字符串的大小时,不能直接用来相减,因为strlen返回的是无符号整形,对于二进制位来说,最高位为符号位,当为无符号位时,最高位也会用来计算,会是一个很大的数,因此计算时可以强制转换成int类型,或者直接将他们进行比较(strlen(str2)>strlen(str1)),这样就不会发生计算

1.2strlen函数的模拟实现

#include 
int my_strlen(const char* str1)
{
	int count = 0;
	while ( * str1!='\0')
	{
		str1++;
		count++;
	}
	return count;
}
int main()
{
	char* str1 = "abcdef";
	int count = my_strlen(str1);
	printf("%d", count);
	return 0;
}

运行结果:
在这里插入图片描述
当然还可以用递归方式,指针减去指针的方式来模拟实现

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

2.1strcpy的使用

在这里插入图片描述
拷贝由source所指向的源原字符串拷贝到destination所指向的目的地字符串,返回的是一个char*类型的指针

  • 源字符串必须以’\0’结束。
  • 会将源字符串中的’\0’拷贝到目标空间
  • 目标空间必须可变
#include 
#include 
int main()
{
	char* str1 = "abcdef";
	char str2[20] = { 0 };
	strcpy(str2, str1);
	printf("str2=%s", str2);
	return 0;
}

运行结果:
在这里插入图片描述

2.1.1strcpy函数的模拟实现

#include 
#include 
char* my_strcpy(char* str2, const char* str1)
{
	char* ret = str2;
	assert(str1 && str2);
	while (*str2++ = *str1++)
	{
		;
	}
	return ret;
}
int main()
{
	char* str1 = "abcdef";
	char str2[20] = { 0 };
	char* ret = my_strcpy(str2, str1);
	printf("str2=%s", ret);
	return 0;
}

运行结果:
在这里插入图片描述

assert用来断言是否为空指针,如果是就会报错,不是就继续执行

2.2strcat的使用

在这里插入图片描述
将source指向的源字符串连接到destination指向的字符串的后面,源字符串的第一个字符被写入目标字符串的终止空字符位置高阶C语言|字符函数和字符串函数--函数的模拟实现_第1张图片

  • 源字符串与目标字符串都必须以’\0’结束
  • 目标空间必须有足够的大,能容纳下源字符串的内容。
  • 目标空间必须可修改
#include 
#include 
int main()
{
    char str1[20] = "hello";
	char* str2 = "bit";
	strcat(str1, str2);
	printf("str1=%s", str1);
	return 0;
}

运行结果:
在这里插入图片描述

2.2.1strcat函数的模拟实现

#include 
#include 
char* my_strcat(char* str1, const char* str2)
{
	char* ret = str1;
	assert(str1 && str2);
	//寻找到'\0'的位置
	while (*str1)
	{
		str1++;
	}
	//开始拷贝
	while (*str1++ = *str2++)
	{
		;
	}
	return ret;
}
int main()
{
    char str1[20] = "hello";
	char* str2 = "bit";
	char* ret = my_strcat(str1, str2);
	printf("str1=%s", str1);
	return 0;
}

运行结果:
在这里插入图片描述
那么问题来了,字符串能不能给自己追加呢?以模拟的代码来分析
高阶C语言|字符函数和字符串函数--函数的模拟实现_第2张图片
首先源头与目标都指向统一位置,目标寻找到终止空字符位置,后进行拷贝,第一次拷贝h,直到将’\0’拷贝完就停止,但是第一次拷贝的时候就将’\0’覆盖了,后面拷贝就找不到’\0’了,就会死循环下去。所以答案就是最好不要自己给自己追加字符串。

2.3strcmp的使用

在这里插入图片描述
比较相同位置的字符,相等则比较下一对字符,不相等,判断谁大,返回相应的数字,返回类型为int类型
高阶C语言|字符函数和字符串函数--函数的模拟实现_第3张图片

  • 第一个字符串大于第二个字符串,则返回大于0的数字
  • 第一个字符串等于第二个字符串,则返回0
  • 第一个字符串小于第二个字符串,则返回小于0的数字
#include 
#include 
int main()
{
    char* str1= "hello";
	char* str2 = "bit";
	int ret = strcmp(str1, str2);
	printf("ret=%d", ret);
	return 0;
}

运行结果:
在这里插入图片描述

2.3.1strcmp函数的模拟实现

#include 
#include 
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	//当比较到'\0'或者不相等时就可以停下来
	while (str1 && str2 && *str1++ == *str2++)
	{
		;
	}
	int ret=str1 - str2;
	if (ret > 0)
	{
		return 1;
	}
	else if (ret < 0)
	{
		return -1;
	}
	else
	{
		return 0;
	}
}
int main()
{
    char* str1= "hello";
	char* str2 = "bit";
	int ret = my_strcmp(str1, str2);	
	printf("ret=%d", ret);
	return 0;
}

运行结果:
在这里插入图片描述

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

3.1strncpy

在这里插入图片描述

  • 拷贝num个字符从源字符串到目标空间。
  • 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后便追加0,知道num个。
#include 
#include 
int main()
{
	char str1[20] = { 0 };
	char* str2 = "bit";
	strncpy(str1, str2,5);	
	printf("str1=%s", str1);
	return 0;
}

运行结果:
在这里插入图片描述

3.2strncat

在这里插入图片描述

  • 将源字符串的前num个字符追加到目标字符串的末尾,并在末尾添加一个终止空字符。
  • 如果源字符串的长度小于num,则只复制到终止空字符的位置。
#include 
#include 
int main()
{
	char str1[20] = "hello";
	char* str2 = "bit";
	strncat(str1, str2,5);	
	printf("str1=%s", str1);
	return 0;
}

运行结果:
在这里插入图片描述

3.3strncmp

在这里插入图片描述

该函数从每个字符串的第一个字符开始比较,如果它们相等,则继续比较接下来的字符对,直到遇到不同的字符、终止空字符或者两个字符串都匹配了num个字符为止。

#include 
#include 
int main()
{
	char str[][5] = { "R2D2", "C3PO","R2A6" };
	int n;
	puts("Looking for R2 astromech droids...");
	for (n = 0; n < 3; n++)
	{
		if (strncmp(str[n], "R2xx", 2) == 0)
		{
			printf("found %s\n", str[n]);
		}
		
	}
	return 0;
}

运行结果:
高阶C语言|字符函数和字符串函数--函数的模拟实现_第4张图片

四、字符串查找

4.1strstr的使用

在这里插入图片描述

返回指向str1中第一次出现str2的指针,如果str2不在str1中,则返回null指针。俗话就是strstr()函数用于查找一个字符串是否包含另一个字符串,并返回第一个匹配的位置。

#include 
#include 
int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = strstr(str, "simple");
	strncpy(pch, "sample", 6);
	puts(str);
	return 0;
}

运行结果:
在这里插入图片描述

4.1.1strstr函数的模拟

#include 
#include 
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);//断言str1和str2是否为空指针
	char* cp = (char*)str1;
	char* sstr1 ;
	char* sstr2 ;
	//*str2为'\0'返回str1的地址
	if (!*str2)
		return (char*)str1;
	while(*cp)
	{
		int count = 0;
		sstr1 = cp;
		sstr2 = (char*)str2;
		while (sstr1 && sstr2 && *sstr1++ == *sstr2++)
		{
			;
		}
		if (!*sstr2)
			return cp;
		cp++;
	}
	return NULL;
}
int main()
{
	char str[] = "This is a simple string";
	char* pch = my_strstr(str, "simple");	
	puts(pch);
	return 0;
}

运行结果:
在这里插入图片描述

4.2strtok

在这里插入图片描述

  • sep参数是个字符串,定义了分隔符的字符集合
  • 第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
  • strtok函数找到str中的下一个标记,并将其用’\0’结尾,返回一个指向这个标记的指针。(注:strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。)
  • strtok函数的第一个参数不为NULL,函数将找到str中第一个标记,strtok函数将保存他在字符串中的位置。
  • strtok函数的的一个参数为NULL,函数将在同一个字符串中被保存的位置开始,查找下一个标记。
  • 如果字符串中不存在更多的标记,则返回NULL指针。
#include 
#include 
int main()
{
	char str[] = "[email protected]#566&520";
	char sep[] = "@.# & ";//分隔符,strtok找到str中下一个标记就是分隔符,找到之后会将分隔符置为'\0',所以最好拷贝一下内容
	//返回指向该标记的指针,同时返回分隔符前面字段的第一个字符的地址
	char arr[30];
	strcpy(arr, str);
	char* p = NULL;
	//当第一个参数不为NULL时,找到第一个标记,strtok会保存该标记的位置
	//当第一个参数为NULL时,函数将在同一个字符串中被保存的位置开始查找,直到下一个标记
	//如果字符串没有标记了,则返回空指针
	for (p = strtok(arr, sep); p != NULL; p = strtok(NULL, sep))
	{
		printf("%s\n", p);
	}
	return 0;
}

运行结果:
高阶C语言|字符函数和字符串函数--函数的模拟实现_第5张图片

五、错误信息报告

5.1strerror

在这里插入图片描述

  • 错误码存放到errnum中,解释errnum的值,生成一个描述错误条件的字符串,就像通过库函数设置了errno一样。
  • 该函数返回指向静态分配字符串的指针,该字符串不应被程序修改。进一步调用此函数可能会覆盖其内容(特定的库实现不需要避免数据竞争)。
  • strerror生成的错误字符串可能因系统和库实现而异。
#include 
#include 
#include 
int main()
{
	FILE* pFile;
	pFile = fopen("test.txt", "r");
	if (pFile == NULL)
	{
		printf("Error opening file test.txt:%s\n", strerror(errno));
		//也可以用perror
		perror(pFile);
	}
	return 0;
}

运行结果:
高阶C语言|字符函数和字符串函数--函数的模拟实现_第6张图片

六、字符操作

高阶C语言|字符函数和字符串函数--函数的模拟实现_第7张图片
字符转换:

int tolower(int c);//大写转小写
int toupper(int c);//小写转大写

#include 
#include 
int main()
{
	int i = 0;
	char str[] = "Test String.\n";
	char c;
	while (str[i])
	{
		c = str[i];
		if (isupper(c))//是大写返回真
			c=tolower(c);//转小写
		putchar(c);
		i++;
	}
	return 0;
}

运行结果:
在这里插入图片描述

七、内存操作函数

7.1memcpy的使用

在这里插入图片描述

  • 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。因为目标和源头的返回的类型是void*,故可以接收任何类型的数据的拷贝。
  • 这个函数在遇到’\0’的时候并不会停下来。
  • 如果source和destination有任何的重叠,复制的结果都是未定义的。
#include 
#include 
struct {
	char name[40];
	int age;
}person;
int main()
{
	char myname[] = "Pierre de Fermat";
	memcpy(person.name, myname, strlen(myname) + 1);
	printf("%s\n", person.name);
	return 0;
}

运行结果:
在这里插入图片描述

7.1.1memcpy函数的模拟

#include 
#include 
void* my_memcopy(void* str2, const void* str1, size_t num)
{
	void* ret = str2;
	assert(str2 && str1);
	while (num--)
	{
		//完成每一对字节的交换
		*(char*)str2 = *(char*)str1;
		str2 = (char*)str2 + 1;
		str1 = (char*)str1 + 1;
	}
	return ret;
}
int main()
{
	int str1[20] = { 1,2,3,4,5,6,7,8,9,10 };
	int str2[20] = { 0 };
	int* pc = (int*)my_memcopy(str2, str1, 40);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", pc[i]);
	}
	return 0;
}

7.1.2memcpy的source与destination的重叠

#include 
#include 
void* my_memcopy(void* str2, const void* str1, size_t num)
{
	void* ret = str1;
	assert(str2 && str1);
	while (num--)
	{
		//完成每一对字节的交换
		*(char*)str2 = *(char*)str1;
		str2 = (char*)str2 + 1;
		str1 = (char*)str1 + 1;
	}
	return ret;
}
int main()
{
	int str1[20] = { 1,2,3,4,5,6,7,8,9,10 };
	//int str2[20] = { 0 };
	int* pc = (int*)my_memcopy(str1+2, str1, 20);//将12345复制到34567这个位置
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", pc[i]);
	}
	return 0;
}

按照预期得到的结果是12123458910,然而却是:
在这里插入图片描述
这是因为:
高阶C语言|字符函数和字符串函数--函数的模拟实现_第8张图片
3已经被1覆盖了,再用3赋值给5时也是1了,同理4也一样。所以memcpy这个函数最好不要有任何的重叠,即memcpy只要实现了不重叠拷贝就行,但是在VS上却可以实现重叠拷贝,这是因为编译器的差异。

7.2memmove的使用

在这里插入图片描述

  • 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
  • 如果源空间和目标空间出现重叠,就得使用memmove函数处理。
#include 
#include 
int main()
{
	int arr[20] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr + 2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

运行结果:
在这里插入图片描述
由结果可知memmove可以实现重叠,那么如何去模拟实现这个函数呢?

7.2.1memmove函数的模拟

分析:
高阶C语言|字符函数和字符串函数--函数的模拟实现_第9张图片

#include 
#include 
void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	if (src < dest)
	{
		void* ret = src;
		//从后向前开始拷贝
		src = (char*)src + num-1;
		dest = (char*)dest + num-1;
		while (num--)
		{
			*(char*)dest = *(char*)src;
			src = (char*)src - 1;
			dest = (char*)dest - 1;
		}
		return ret;
	}
	else
	{
		void* ret = dest;
		while (num--)
		{
		//从前向后拷贝
			*(char*)dest = *(char*)src;
			src = (char*)src + 1;
			dest = (char*)dest + 1;
		}
		return ret;
	}
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	int* pc=(int*)my_memmove(arr1+2 , arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", pc[i]);
	}
	return 0;
}

运行结果:
在这里插入图片描述

7.3memcmp

在这里插入图片描述

  • 比较指针ptr1指向的内存块的前num个字节和指针ptr2指向的内存块的前num个字节,如果它们都匹配,则返回0;如果它们不匹配,则返回一个值,表示哪个更大。
  • 需要注意的是,与strcmp不同,该函数在找到空字符后不会停止比较。
#include 
int main()
{
	char* str1 = "alfjlkfafj";
	char* str2 = "alffljaoiogi";
	int n =memcmp(str1, str2, 8);
	if (n > 0)
		printf("str1>str2\n");
	else if (n < 0)
		printf("str2);
	else
		printf("str1=str2\n");
	return 0;
}

运行结果:
在这里插入图片描述
end~

你可能感兴趣的:(c语言)