字符函数和字符串函数

• 求字符串长度---strlen
• 长度不受限制的字符串函数---strcpy strcat strcmp
• 长度受限制的字符串函数介绍 ---strncpy strncat strncmp
• 字符串查找 ---strstr strtok
• 错误信息报告 ---strerror
• 字符操作
• 内存操作函数 ---memcpy memmove memset memcmp

  ---

  1.strlen

size_t strlen ( const char * str );

1.字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )。

2.返回值是size_t,无符号的

模拟实现：

//使用计数器，遍历字符串，count逐次加1 ；
unsigned int my_strlen(const char* s)
{
 assert(s);
 int count = 0;
 while (*s != '\0')
 {
  s++;
  count++;
 }
 return count;
}
 
//通过指针相减得到字符长度.
unsigned int my_strlen(const char* s)
{
 assert(s);
 const char* p = s;
 while (*p != '\0')
  p++;
 
 return p - s;
}
 
//使用递归方法;
unsigned int my_strlen(const char* s)
{
 assert(s);
 if (*s == '\0')
  return 0;
 else
  return 1 + my_strlen(s + 1);
}

2.strcpy

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

1.源字符串必须以 '\0' 结束。

2.会将源字符串中的 '\0' 拷贝到目标空间。

3.目标空间必须足够大，以确保能存放源字符串。

4.目标空间必须可变。

模拟实现

char* my_strcpy(char* d,char* s) {
	assert(d && s);
	char* ret=d;
	while (*d++ = *s++) {
		;
	}
	return ret;
}

这里代码很妙，特别是while中的判断语句。

3.strcat

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

源字符串必须以 '\0' 结束。

目标空间必须有足够的大，能容纳下源字符串的内容。

目标空间必须可修改。

字符串自己给自己追加，自己实现时会出现死循环，但是vs2019中库函数使用没有问题

模拟实现

char* my_strcat(char* d, const char* s) {
	assert(d && s);
	char* ret = d;
	while (*d) {
		d++;
	}
	while (*d++ = *s++) {
		;
	}
	return ret;
}

4.strcmp

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

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

strncpy，strncat，strncmp和前面的大同小异，只是限制了长度。

5.strstr

char * strstr ( const char *str1, const char * str2);

该函数是用来判断str2是不是str1的子串，返回str1中str2的位置

模拟实现

char* my_strstr(const char* str1, const char* str2) {
	assert(str1 && str2);
	const char* s1 = str1;
	const char* s2 = str2;
	const char* cur = str1;
	while (*cur) {
		s1 = cur;
		s2 = str2;
		while ((*s1 == *s2) && s1 && s2) {
			s1++;
			s2++;
		}
		if (*s2 == '\0') {
			return (char*)cur;
		}
		cur++;
	}
	return NULL;
}

这个和数据结构中的KMP算法实现结果是相同的，可以去了解一下KMP算法

6.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* p = "2022/3/23&zai";
	const char* sep = "/&";
	char arr[30];
	char* str = NULL;
	strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
}

 这个函数挺有意思的。但模拟实现也蛮困难的……

7.strerror

char * strerror ( int errnum );

用来返回错误信息，和perror相比，是perror是一定会打印出来。

8.memcpy

void * memcpy ( void * destination, const void * source, size_t num );

和strcpy很像，不过它可以实现更多类型的复制

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 '\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制结果不能确定，照理说，会出现错误，但是现在库函数已经更新了，所以……现在也是没有问题的。

模拟实现

void* memcpy(void* d, const void* s, size_t count) {
	assert(d && s);
	void* ret = d;
	while (count--) {
		*(char*)d = *(char*)s;
		d = (char*)d + 1;
		s = (char*)s + 1;
	}
	return ret;
}

9.memmove

void * memmove ( void  * destination, const void * source, size_t num );

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

模拟实现

void* my_memmove(void* d, const void* s, size_t count) {
	assert(d && s);
	void* ret = d;
	if (d < s) {
		while (count--) {
			*(char*)d = *(char*)s;
			d = (char*)d + 1;
			s = (char*)s + 1;
		}
	}
	else {
		while (count--) {
			*((char*)d+ count)=*((char*)s + count);
		}
	}
	return ret;
}

 因为有覆盖，所以当dest<src时，从前到后复制，否则，从后往前复制。

10.memcmp

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

与strcmp相比，不同的是这是一个一个字节比较。