【字符串函数使用和实现详解_C语言实现】

本文主要写的是常用的字符串函数

首先咱们来一个简单题

以下代码输出的是什么：

int main()
{
	char stra[] = { "yc" };
	char strb[] = { "yc" };
	
	char* pa = "yc";
	char* pb = "yc";

	printf("%d \n", (stra == strb));	
	printf("%d \n", (pa == pb));		
	return 0;
}

答案：（比较简单，我就不解释了）（当然也可以私信问我）
0
1

字符串检验函数

strlen函数的实现_ my_strlen()

返回给定空终止字符串的长度，即首元素为 str 所指，且不包含首个空字符的字符数组中的字符数。
若 str 不是指向空终止字节字符串的指针则行为未定义。

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

strcmp函数的实现_ my_strcmp()

比较二个空终止字节字符串。
结果的符号是被比较的字符串中首对不同字符（都转译成 unsigned char ）的值间的差的符号。

若 lhs 或 rhs 不是指向空终止字节字符串的指针，则行为未定义。

int my_strcmp(const char* sp, const char* rp)
{
	assert(sp != NULL && rp != NULL);
	while (*sp != '\0' && *rp != '\0' && *sp == *rp)
	{
		sp++;
		rp++;
	}
	return (*sp - *rp);
}

也可以这样写

int my_strcmp(const char* sp, const char* rp)
{
	assert(sp != NULL && rp != NULL);
	int k = 0;
	while ((k = *sp - *rp) == 0 && *sp++ && *rp++);
	return k;
}

strncmp函数的实现_ my_strncmp()

比较二个可能空终止的数组的至多 count 个字符。按字典序进行比较。不比较后随空字符的字符。
结果的符号是被比较的数组中首对字符（都转译成 unsigned char ）的值间的差的符号。
若出现越过 sp 或 rp 结尾的访问，则行为未定义。若 sp 或 rp 为空指针，则行为未定义。

int my_strncmp(const char* sp, const char* rp,size_t count)
{
	assert(sp != NULL && rp != NULL);
	if (0 == count) return 0;
	while (*sp != '\0' && *rp != '\0' && *sp == *rp && --count)
	{
		sp++;
		rp++;
	}
	return (*sp - *rp);
}

size_t ==> unsigned int (无符号整型)

strchr函数的实现_ my_strchr()

寻找 ch （如同用 (char)ch 转换成 char 后）在 str 所指向的空终止字节字符串（转译每个字符为 unsigned char ）中的首次出现位置。终止空字符被认为是字符串的一部分，并且能在寻找 ‘\0’ 时找到。
若 str 不是指向空终止字节字符串的指针，则行为未定义。

char* my_strchr(const char* str, char ch)
{
	if (str == NULL) return NULL;
	//定义一个临时变量，不修改原指针指向
	char* p = (char*)str;
	while (*p != ch)
	{
		p++;
		if (*p == '\0')
		{
			p = NULL;
			break;
		}	
	}
	return p;
}

strrchr函数的实现_ my_strrchr()

寻找 ch （如同用 (char)ch 转换到 char 后）在 str 所指向的空终止字节串中（将每个字符转译成 unsigned char ）的最后出现。若搜索 ‘\0’ ，则认为终止空字符为字符串的一部分，而且能找到。
若 str 不是指向空终止字节串的指针，则行为未定义。
（直接从尾往前寻找即可）

char* my_strrchr(const char* str, char ch)
{
	if (str == NULL) return NULL;
	char* p = (char*)str;
	p = p + my_strlen(str) - 1;
	while (str != p--)
	{
		if (*p == ch)
		{
			return p;
		}
	}
	return NULL;
}

字符串操作函数

strstr函数的实现_ my_strstr()

查找 substr 所指的空终止字节字符串在 str 所指的空终止字节字符串中的首次出现。不比较空终止字符。
若 str 或 substr 不是指向空终止字节字符串的指针，则行为未定义。
str - 指向要检验的空终止字节字符串的指针
substr - 指向要查找的空终止字节字符串的指针

char* my_strstr(const char* str, const char* substr)
{
	if (NULL == str || NULL == substr) return NULL;
	int n = my_strlen(str);
	int m = my_strlen(substr);
	for (int i = 0; i < n - m + 1; ++i)
	{
		int k = i;
		int j = 0;
		while (j < m && str[k] == substr[j])
		{
			j++;
			k++;
		}
		if (j == m)
		{
			return(char*)str + i;
		}
	}
	return NULL;
}

当然也可以不定义第三个变量

char* my_strstr_2(const char* str, const char* substr)
{
	if (NULL == str || NULL == substr) return NULL;
	int n = my_strlen(str);
	int m = my_strlen(substr);
	int i = 0;
	int j = 0;
	while (i < n - m + 1 && j < m)
	{
		if (str[i] == substr[j])
		{
			i++; j++;
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}
	}
	
	if (j == m)
	{
		return(char*)str + i - j;
	}
	else
	{
		return NULL;
	}
}

strcpy函数的实现_ my_strcpy()

复制 src 所指向的空终止字节字符串，包含空终止符，到首元素为 dest 所指的字符数组。
若 dest 数组长度不足则行为未定义。若字符串覆盖则行为未定义。若 dest 不是指向字符数组的指针或 src 不是指向空终止字节字符串的指针则行为未定义。

char* my_strcpy(char* dest, const char* src)
{
	assert(dest != NULL && src != NULL);
	char* cp = dest;
	//while (*src != '\0')
	//{
	//	//*cp = *src;
	//	//cp++;
	//	//src++;
	//	*cp++ = *src++;//跟上面等价
	//}
	//*cp = '\0';
	while (*cp++ = *src++);		//跟上面等价
	return dest;
}

strcat函数的实现_ my_strcat()

后附 src 所指向的空终止字节字符串的副本到 dest 所指向的空终止字节字符串的结尾。字符 src[0] 替换 dest 末尾的空终止符。产生的字节字符串是空终止的。
若目标数组对于 src 和 dest 的内容以及空终止符不够大，则行为未定义。若字符串重叠，则行为未定义。若 dest 或 src 不是指向空终止字节字符串的指针，则行为未定义。

char* my_strcat(char* dest, const char* src)
{
	assert(src != NULL && dest != NULL);
	char* cp = dest;
	while (*cp != '\0')
	{
		cp++;
	}
	while (*cp = *src)
	{
		cp++;
		src++;
	}
	return dest;
}

也可以调用前面写好的函数，如下：

char* my_strcat_a(char* dest, const char* src)
{
	assert(src != NULL && dest != NULL);
	char* cp = dest + my_strlen(dest);
	my_strcpy(cp, src);
	return dest;
}

strdup函数的实现_ my_strdup()

返回指向作为 src 所指向的字符串的副本的空终止字节字符串的指针。如同通过调用 malloc 获得新字符串的空间。必须将返回的指针传递给 free 以避免内存泄漏。
若出现错误，则返回空指针值并可能设置 errno 。

char* my_strdup(const char* src)
{
	if (NULL == src) return NULL;
	int len = my_strlen(src) + 1;
	char* s = (char*)malloc(sizeof(char) * len);
	my_strcpy(s, src);
	return s;
}

此时呢，常用的字符串函数已经全部完成了。。。