字符串函数的使用详解和模拟实现

strlen------求字符串长度

size_t strlen ( const char * str );
strlen里面必须是地址，否则会报错的
字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包
含 ‘\0’ )。
参数指向的字符串必须要以 ‘\0’ 结束。
注意函数的返回值为size_t，是无符号的（ 易错 ）

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "abc";
	if (strlen(arr2) - strlen(arr1))
		printf("冬天好冷\n");
	else
		printf("夏天好热\n");
	return 0;
}
//打印了冬天好冷，说明什么？ strlen的返回值是无符号数，无符号数减无符号数还是无符号数

关于strlen的模拟实现
有三种方法
1 计数器方法

int my_strlen(const char* arr)
{
	assert(arr != NULL);
	int count = 0;
	while (*arr != '\0')
	{
		count++;
		arr++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdefg";
	int ret = my_strlen(arr);
	printf("%d\n", ret);
	return 0;
}

2指针减指针的方法

int my_strlen(const char* arr)
{
	const char* p = arr;
	assert(arr != NULL);
	while (*p != '\0')
		p++;
	return p - arr;
}
int main()
{
	char arr[] = "abcdefg";
	int ret = my_strlen(arr);
	printf("%d\n", ret);
	return 0;
}

3递归的方法

int my_strlen(const char* arr)
{
	if (*arr != '\0')
		return 1 + my_strlen(arr + 1);
	else
		return 0;
}

int main()
{
	char arr[] = "abcdefg";
	int ret = my_strlen(arr);
	printf("%d\n", ret);
	return 0;
}

strcpy--------字符串拷贝函数

char* strcpy(char * destination, const char * source );
源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。

模拟实现strcpy

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;  //保存目的空间的起始地址
	assert(dest && src);
	while (*dest++ = *src++);
	return ret;
}

int main()
{
	char arr1[100] = { 0 };
	char arr2[] = "abcdefg";
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}

strcat-----字符串追加函数

源字符串必须以 ‘\0’ 结束，因为会将\0追加上去
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改
从目标空间的’\0’位置开始追加
字符串自己不能追加自己

char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;  //保存目的空间的起始地址
	assert(dest&&src);
	while (*dest != '\0')
		dest++;
	while (*dest++ = *src++);
	return ret;
}
int main()
{
	char arr1[100] = "xxxxxxx";
	char arr2[] = "abcdefg";
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;
}

strcmp—字符串比较函数

int strcmp ( const char * str1, const char * str2 );
他的比较规则是比较每一对的ASCLL码值
若第一对就不同，则只比较第一对。

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

模拟实现

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 arr1[] = "abcdef";
	char arr2[] = "abcdeg";
	int ret=my_strcmp(arr1, arr2);
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret < 0)
		printf("arr1<arr2\n");
	else
		printf("arr1==arr2\n");
}

strncpy------已知个数的字符串拷贝函数

char * strncpy ( char * destination, const char * source, size_t num );
源头向目的地拷贝num个字符

strncat 已知个数的字符串追加函数

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

strncmp-----已知个数的字符串的比较函数

int strncmp ( const char * str1, const char * str2, size_t num );
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

strstr------找字符串函数

若找到，返回地址，没找到，返回空指针。
例如

    char arr1[] = "abcdfeghijk";
	char arr2[] = "feg";
	char* ret = strstr(arr1, arr2); //从arr1中找字符串
	printf("%s\n", ret);  //会打印feghijk，返回的f的地址

模拟实现strstr

char* my_strstr(const char* str, const char* substr)
{
	const char* cur = str;
	assert(str && substr);
	if (*substr == '\0')
		return (char*)cur;
	while (*cur)
	{
		const char* s1 = cur;
		const char* s2 = substr;
		while (*s1 == *s2 && s2 != '\0')
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)cur;
		cur++;
	}
	return NULL;
}
int main()
{

	char arr1[] = "abbbbcdfeg";
	char arr2[] = "bbc";
	 char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
		printf("未找到\n");
	else
		printf("%s\n", ret);
	return  0;
}

strtok----字符串分割函数

char * strtok ( char * str, const char * sep );
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标
记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容
并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串
中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标
记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

int main()
{
	char str1[] = "dashuaibi@qq.com";
	char buf[20] = { 0 };
	char sep[] = "@.";
	char* p = NULL;
	strcpy(buf, str1);
	for (p = strtok(buf, sep);  p != NULL; p=strtok(NULL, sep))
	{
		printf("%s\n", p);
	}
	return 0;
}

strerror-----返回错误信息函数

char * strerror ( int errnum）；
errno是全局的错误码，发生错误就返回对应的数字。

#include <errno.h>
int main()
{
	FILE* pFile;
	pFile = fopen("test.abc", "r");  //这个工程里没有文件
	if (pFile == NULL)
	printf("%s\n", strerror(errno));//会打印No such file or directory
	return 0;
}

字符分类函数：

如果参数符合条件就返回真，否则返回假

memcpy 内存拷贝函数

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。
模拟实现

memmove内存拷贝函数（可以拷贝重叠内存）

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

void* my_memmove(void* dest, const void* src,int num)
{
	void* ret = dest;   //保存目的空间的起始地址
    assert(dest && src);
	if (dest > src) //从后向前拷贝
	{
		while (num)
		{
			*((char*)dest + num - 1) = *((char*)src + num - 1);
			num--;
		}
	}
	else  //从前向后拷贝
	{
		while (num)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
			num--;
		}
	}
	return  ret;
}

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