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

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

一、求字符串长度

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指向的字符串的后面，源字符串的第一个字符被写入目标字符串的终止空字符位置

• 源字符串与目标字符串都必须以’\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;
}

运行结果：

那么问题来了，字符串能不能给自己追加呢？以模拟的代码来分析

首先源头与目标都指向统一位置，目标寻找到终止空字符位置，后进行拷贝，第一次拷贝h,直到将’\0’拷贝完就停止，但是第一次拷贝的时候就将’\0’覆盖了，后面拷贝就找不到’\0’了，就会死循环下去。所以答案就是最好不要自己给自己追加字符串。

2.3strcmp的使用

比较相同位置的字符，相等则比较下一对字符，不相等，判断谁大，返回相应的数字，返回类型为int类型

• 第一个字符串大于第二个字符串，则返回大于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;
}

运行结果：

四、字符串查找

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;
}

运行结果：

五、错误信息报告

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;
}

运行结果：

六、字符操作

字符转换：

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，然而却是：

这是因为：

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函数的模拟

分析：

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