【C语言进阶10——字符和字符串函数及其模拟实现（1）】

---

前言

本文开始学习字符函数和字符串库函数的使用，并用了前面所学的知识模拟实现这些库函数。

库函数推荐查询工具官网：

• MSDN(Microsoft Developer Network)
• www.cplusplus.com
• http://en.cppreference.com（英文版）
• http://en.cppreference.com（中文版）

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

本文主要内容包括：

1、求字符串长度

• strlen

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

• strcpy
• strcat
• strcmp

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

• strncpy
• strncat
• strncmp

---

1、求字符串长度的函数

在前文中分别学习了用一般方法、递归、指针的方式模拟实现过库函数 strlen 来读取字符串的长度

• 【C语言基础4——函数（2）】7.4 练习 2
• 【C语言基础11——指针（2）】4.2 指针-指针
• 【读取字符串长度的库函数 strlen 及其模拟实现】

1.1 库函数 strlen

size_t strlen ( const char * str );

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

使用库函数：
int main() 
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	if (strlen(str2)-strlen(str1)>0)//字符串长度相比较
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("str1>str2\n");
	}
	return 0;
}

1.2 模拟实现库函数 strlen

int my_strlen(const char* str)//常量指针，限制字符串，在传递过程中不可以被修改
{
	assert(str != NULL);//当str为空指针时，程序报错
	char* p = str;//记录首元素地址的位置
	while (*p != '\0')
	{
		p++;
	}
	return p - str;//尾地址-首地址，就是字符串的长度
}

int main()
{
	//int len = strlen("abcdef");
	int len = my_strlen("abcdef");

	printf("%d\n", len);
	return 0;
}

输出结果见下图：

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

2.1 库函数 strcpy

char* strcpy(char * destination, const char * source );

• 源字符串必须以 ‘\0’ 结束
• 会将源字符串中的 ‘\0’ 拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串
• 目标空间必须可变

int main()
{
	char  a[10] = "x";
	//char* a1 = "qwertyuop";//常量字符串不可修改
	char a2[] = "abcdef";

	strcpy(a, a2);
	printf("%s\n", a);
	return 0;
}

2.2 模拟实现库函数 strcpy

char* my_strcpy(char* dest, const char* src)
{
	//assert(dest != NULL);
	//assert(src != NULL);
	assert(dest && src);//同上面的两种写法
	char* ret = dest;//记录指针起始位置
	while (*dest = *src)
	{
		dest++;
		src++;
	}
	/*while ( *src !='\0')//不够简洁
	{
		*dest = *src;
		dest++;
		src++
	}
	*dest = '\0';*/
	return ret;
}
int main()
{
	char  a[10] = "x";
	//char* a1 = "qwertyuop";//常量字符串不可修改
	char a2[] = "abcdef";

	printf("%s\n", my_strcpy(a, a2));//链式
	return 0;
}

输出结果见下图：

2.3 库函数 strcat

char * strcat ( char * destination, const char * source );

• 源字符串必须以 ‘\0’ 结束
• 目标空间必须有足够的大，能容纳下源字符串的内容
• 目标空间必须可修改

int main()
{
	char a1[20] = "hello ";
	char a2[] = "world";
	strcat(a1, a2);
	printf("%s\n", a1);
	return 0;
}

2.4 模拟实现库函数 strcat

char* my_strcat(char* dest, const char* src)
{
	assert(src&&dest);
	char* ret = dest;
	//找字符串结束标志 '\0'
	while (*dest)
	{
		dest++;
	}
	//开始拷贝字符串
	while (*dest++ == *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char a1[20] = "hello ";
	char a2[] = "world";

	printf("%s\n", my_strcat(a1, a2));
	return 0;
}

输出结果见下图：

2.5 库函数 strcmp

int strcmp ( const char * str1, const char * str2 );

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

int main()
{
	char a1[] = "abcd";
	char a2[] = "abdc";
	
	int ret= strcmp(a1, a2);
	if (ret>0)
	{
		printf(">\n");
	}
	else if (ret==0)
	{
		printf("==\n");
	}
	else
	{
		printf("<\n");
	}
	printf("%d\n", ret);

	return 0;
}

2.6 模拟实现库函数 strcmp

int my_strcmp(const char* s1, const char* s2)
{
	assert(s1&&s2);
	while (*s1 == *s2)
	{
		if (*s1=='\0')//一致到末尾，代表字符串结束
		{
			return 0;
		}
		s1++;
		s2++;
	}
	//返回差值
	return *s1 - *s2;
}
int main()
{
	char a1[] = "abcd";
	char a2[] = "abdc";
	
	int ret = my_strcmp(a1, a2);
	if (ret>0)
	{
		printf(">\n");
	}
	else if (ret==0)
	{
		printf("==\n");
	}
	else
	{
		printf("<\n");
	}
	printf("%d\n", ret);

	return 0;
}

输出结果见下图：

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

3.1 库函数 strncpy

char * strncpy ( char * destination, const char * source, size_t num );

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

int main()
{
	char a1[] = "abcdef";
	char a2[] = "qwe";
	strncpy(a1, a2, 4);
	printf("%s\n", a1);
	return 0;
}

3.2 模拟实现库函数 strncpy

char* my_strncpy(char* dest, const char* src, int cnt)
{
	assert(dest&&src);
	char *ret = dest;

	while (cnt && (*dest++ = *src++) != '\0')
	{
		cnt--;
	}
	//如果源字符串字符个数小于cnt,拷完源字符串后，在后面接着补字符'\0',直到为cnt个
	if (cnt)
	{
		while (--cnt)
		{
			*dest++ = '\0';
		}		
	}
	return ret;
}

int main()
{
	char a1[] = "abcdef";
	char a2[] = "qwe";
	strncpy(a1, a2, 4);
	printf("%s\n", a1);
	printf("%s\n", my_strncpy(a1, a2, 4));

	return 0;
}

输出结果见下图：

3.3 库函数 strncat

char * strncat ( char * destination, const char * source, size_t num );

• 将源的第一个num字符加上终止的null字符追加到目标
• 如果源代码中的字符串长度小于num，则只复制直到终止空字符 ‘\0’ 的内容

int main()
{
	char a1[20] = "ab";
	char a2[] = "qwe";
	strncat(a1,a2,5);
	printf("%s\n", a1);
	return 0;
}

3.4 模拟实现库函数 strncat

char* my_strncat(char* dest, const char* src,int cnt)
{
	assert(dest&&src);
	char* ret = dest;

	while (*dest)//将指针移到字符串末尾'\0'处
	{
		dest++;
	}	
	while (cnt--)//拷贝字符的个数
	{
		*dest++ = *src++;
		if (*dest)//这里如果拷贝到字符'\0'，就结束了
		{
			return ret;
		}
	}
	//当源字符串长度大于 cnt时，末尾补一个'\0'
	*dest = '\0';
	return ret;
}

int main()
{
	char a1[10] = "ab";
	char a2[] = "qwe";
	printf("%s\n", my_strncat(a1, a2, 5));
	return 0;
}

输出结果见下图：

3.5 库函数 strncmp

int strncmp ( const char * str1, const char * str2, size_t num );

• 第一个字符串字符大于对应的第二个字符串的字符，则返回大于0的数字
• 字符串所有的字符相同，则返回0
• 第一个字符串字符小于对应的第二个字符串的字符，则返回小于0的数字

int main()
{
	char a1[] = "abcdef";
	char a2[] = "abcdq";
	int ret = strncmp(a1, a2, 4);
	if (ret > 0)
	{
		printf(">\n");
	}
	else if (ret == 0)
	{
		printf("==\n");
	}
	else
	{
		printf("<\n");
	}
	return 0;
}

3.6 模拟实现库函数 strncmp

int my_strncmp(const char* s1, const char* s2, int cnt)
{
	assert(s1&&s2);

	while ((cnt-1) && (*s1 == *s2))//这里为cnt就错了
	{
		cnt--;
		if (*s1 == '\0')//一致到末尾，代表字符串结束
		{
			return 0;
		}
		s1++;
		s2++;		
	}
	//返回差值
	return *s1 - *s2;
}
//strncmp
int main()
{
	char a1[] = "abcdef";
	char a2[] = "abcde";
	int ret = my_strncmp(a1, a2, 6);

	if (ret > 0)
	{
		printf(">\n");
	}
	else if (ret == 0)
	{
		printf("==\n");
	}
	else
	{
		printf("<\n");
	}
	return 0;
}

输出结果见下图：

---

总结

本文学习了几个库函数及其模拟实现的代码。

下一篇博文继续学习字符串库函数的相关知识点。